diff --git a/Core/Code/IO/mitkFileReaderSelector.cpp b/Core/Code/IO/mitkFileReaderSelector.cpp
index 4010f686d9..79679e6965 100644
--- a/Core/Code/IO/mitkFileReaderSelector.cpp
+++ b/Core/Code/IO/mitkFileReaderSelector.cpp
@@ -1,298 +1,305 @@
 /*===================================================================
 
 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 "mitkFileReaderSelector.h"
 
 #include <mitkFileReaderRegistry.h>
 #include <mitkCoreServices.h>
 #include <mitkIMimeTypeProvider.h>
 
 #include <usServiceReference.h>
 #include <usServiceProperties.h>
 #include <usAny.h>
 
+#include <itksys/SystemTools.hxx>
+
 namespace mitk {
 
 struct FileReaderSelector::Item::Impl : us::SharedData
 {
   Impl()
     : m_FileReader(NULL)
     , m_ConfidenceLevel(IFileReader::Unsupported)
     , m_Id(-1)
   {}
 
   us::ServiceReference<IFileReader> m_FileReaderRef;
   IFileReader* m_FileReader;
   IFileReader::ConfidenceLevel m_ConfidenceLevel;
   MimeType m_MimeType;
   long m_Id;
 };
 
 struct FileReaderSelector::Impl : us::SharedData
 {
   Impl()
     : m_BestId(-1)
     , m_SelectedId(m_BestId)
   {}
 
   Impl(const Impl& other)
     : us::SharedData(other)
     , m_BestId(-1)
     , m_SelectedId(m_BestId)
   {}
 
   FileReaderRegistry m_ReaderRegistry;
   std::map<long, FileReaderSelector::Item> m_Items;
   std::vector<MimeType> m_MimeTypes;
   long m_BestId;
   long m_SelectedId;
 };
 
 FileReaderSelector::FileReaderSelector(const FileReaderSelector& other)
   : m_Data(other.m_Data)
 {
 }
 
 FileReaderSelector::FileReaderSelector(const std::string& path)
   : m_Data(new Impl)
 {
+  if (!itksys::SystemTools::FileExists(path.c_str()))
+  {
+    return;
+  }
+
   mitk::CoreServicePointer<mitk::IMimeTypeProvider> mimeTypeProvider(mitk::CoreServices::GetMimeTypeProvider());
 
   // Get all mime types and associated readers for the given file path
 
   m_Data->m_MimeTypes = mimeTypeProvider->GetMimeTypesForFile(path);
   if (m_Data->m_MimeTypes.empty()) return;
 
   for (std::vector<MimeType>::const_iterator mimeTypeIter = m_Data->m_MimeTypes.begin(),
        mimeTypeIterEnd = m_Data->m_MimeTypes.end(); mimeTypeIter != mimeTypeIterEnd; ++mimeTypeIter)
   {
     std::vector<FileReaderRegistry::ReaderReference> refs = m_Data->m_ReaderRegistry.GetReferences(*mimeTypeIter);
     for (std::vector<FileReaderRegistry::ReaderReference>::const_iterator readerIter = refs.begin(),
          iterEnd = refs.end(); readerIter != iterEnd; ++readerIter)
     {
       IFileReader* reader = m_Data->m_ReaderRegistry.GetReader(*readerIter);
       if (reader == NULL) continue;
       try
       {
         reader->SetInput(path);
         IFileReader::ConfidenceLevel confidenceLevel = reader->GetConfidenceLevel();
         if (confidenceLevel == IFileReader::Unsupported)
         {
           continue;
         }
 
         Item item;
         item.d->m_FileReaderRef = *readerIter;
         item.d->m_FileReader = reader;
         item.d->m_ConfidenceLevel = confidenceLevel;
         item.d->m_MimeType = *mimeTypeIter;
         item.d->m_Id = us::any_cast<long>(readerIter->GetProperty(us::ServiceConstants::SERVICE_ID()));
         m_Data->m_Items.insert(std::make_pair(item.d->m_Id, item));
         //m_Data->m_MimeTypes.insert(mimeType);
       }
       catch (const us::BadAnyCastException& e)
       {
         MITK_WARN << "Unexpected: " << e.what();
       }
       catch (const std::exception& e)
       {
         // Log the error but continue
         MITK_WARN << "IFileWriter::GetConfidenceLevel exception: " << e.what();
       }
     }
   }
 
   // get the "best" reader
 
   if (!m_Data->m_Items.empty())
   {
     std::set<Item> sortedItems;
     for (std::map<long, Item>::const_iterator iter = m_Data->m_Items.begin(),
          iterEnd = m_Data->m_Items.end(); iter != iterEnd; ++iter)
     {
       sortedItems.insert(iter->second);
     }
     m_Data->m_BestId = sortedItems.rbegin()->GetServiceId();
     m_Data->m_SelectedId = m_Data->m_BestId;
   }
 }
 
 FileReaderSelector::~FileReaderSelector()
 {
 }
 
 FileReaderSelector& FileReaderSelector::operator=(const FileReaderSelector& other)
 {
   m_Data = other.m_Data;
   return *this;
 }
 
 bool FileReaderSelector::IsEmpty() const
 {
   return m_Data->m_Items.empty();
 }
 
 std::vector<MimeType> FileReaderSelector::GetMimeTypes() const
 {
   return m_Data->m_MimeTypes;
 }
 
 std::vector<FileReaderSelector::Item> FileReaderSelector::Get() const
 {
   std::vector<Item> result;
   for (std::map<long, Item>::const_iterator iter = m_Data->m_Items.begin(),
        iterEnd = m_Data->m_Items.end(); iter != iterEnd; ++iter)
   {
     result.push_back(iter->second);
   }
   std::sort(result.begin(), result.end());
   return result;
 }
 
 FileReaderSelector::Item FileReaderSelector::Get(long id) const
 {
   std::map<long, Item>::const_iterator iter = m_Data->m_Items.find(id);
   if (iter != m_Data->m_Items.end())
   {
     return iter->second;
   }
   return Item();
 }
 
 FileReaderSelector::Item FileReaderSelector::GetDefault() const
 {
   return Get(m_Data->m_BestId);
 }
 
 long FileReaderSelector::GetDefaultId() const
 {
   return m_Data->m_BestId;
 }
 
 FileReaderSelector::Item FileReaderSelector::GetSelected() const
 {
   return Get(m_Data->m_SelectedId);
 }
 
 long FileReaderSelector::GetSelectedId() const
 {
   return m_Data->m_SelectedId;
 }
 
 bool FileReaderSelector::Select(const FileReaderSelector::Item& item)
 {
   return Select(item.d->m_Id);
 }
 
 bool FileReaderSelector::Select(long id)
 {
   if (id > -1)
   {
     if (m_Data->m_Items.find(id) == m_Data->m_Items.end())
     {
       return false;
     }
     m_Data->m_SelectedId = id;
     return true;
   }
   return false;
 }
 
 void FileReaderSelector::Swap(FileReaderSelector& fws)
 {
   m_Data.Swap(fws.m_Data);
 }
 
 FileReaderSelector::Item::Item(const FileReaderSelector::Item& other)
   : d(other.d)
 {
 }
 
 FileReaderSelector::Item::~Item()
 {
 }
 
 FileReaderSelector::Item& FileReaderSelector::Item::operator=(const FileReaderSelector::Item& other)
 {
   d = other.d;
   return *this;
 }
 
 IFileReader* FileReaderSelector::Item::GetReader() const
 {
   return d->m_FileReader;
 }
 
 std::string FileReaderSelector::Item::GetDescription() const
 {
   us::Any descr = d->m_FileReaderRef.GetProperty(IFileReader::PROP_DESCRIPTION());
   if (descr.Empty()) return std::string();
   return descr.ToString();
 }
 
 IFileReader::ConfidenceLevel FileReaderSelector::Item::GetConfidenceLevel() const
 {
   return d->m_ConfidenceLevel;
 }
 
 MimeType FileReaderSelector::Item::GetMimeType() const
 {
   return d->m_MimeType;
 }
 
 us::ServiceReference<IFileReader> FileReaderSelector::Item::GetReference() const
 {
   return d->m_FileReaderRef;
 }
 
 long FileReaderSelector::Item::GetServiceId() const
 {
   return d->m_Id;
 }
 
 bool FileReaderSelector::Item::operator<(const FileReaderSelector::Item& other) const
 {
   // sort by confidence level first (ascending)
   if (d->m_ConfidenceLevel == other.d->m_ConfidenceLevel)
   {
     // sort by mime-type ranking
     if (d->m_MimeType < other.d->m_MimeType)
     {
       return true;
     }
     else if (other.d->m_MimeType < d->m_MimeType)
     {
       return false;
     }
     else
     {
       // sort by file writer service ranking
       return d->m_FileReaderRef < other.d->m_FileReaderRef;
     }
   }
   return d->m_ConfidenceLevel < other.d->m_ConfidenceLevel;
 }
 
 FileReaderSelector::Item::Item()
   : d(new Impl())
 {}
 
 void swap(FileReaderSelector& frs1, FileReaderSelector& frs2)
 {
   frs1.Swap(frs2);
 }
 
 }
diff --git a/Core/Code/IO/mitkIOUtil.cpp b/Core/Code/IO/mitkIOUtil.cpp
index e6efc63e21..286fb983b3 100644
--- a/Core/Code/IO/mitkIOUtil.cpp
+++ b/Core/Code/IO/mitkIOUtil.cpp
@@ -1,1070 +1,1077 @@
 /*===================================================================
 
 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 <usGetModuleContext.h>
 #include <usModuleContext.h>
 #include <usLDAPProp.h>
 #include <mitkStandaloneDataStorage.h>
 #include <mitkIDataNodeReader.h>
 #include <mitkProgressBar.h>
 #include <mitkExceptionMacro.h>
 #include <mitkCoreObjectFactory.h>
 #include <mitkFileReaderRegistry.h>
 #include <mitkFileWriterRegistry.h>
 #include <mitkCoreServices.h>
 #include <mitkIMimeTypeProvider.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>
 
 // make the posix flags point to the obsolte bsd types on windows
 #define S_IRUSR S_IREAD
 #define S_IWUSR S_IWRITE
 
 #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_IRUSR | S_IWUSR);
     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
 
 //**************************************************************
 // mitk::IOUtil method definitions
 
 namespace mitk {
 
 const std::string IOUtil::DEFAULTIMAGEEXTENSION = ".nrrd";
 const std::string IOUtil::DEFAULTSURFACEEXTENSION = ".stl";
 const std::string IOUtil::DEFAULTPOINTSETEXTENSION = ".mps";
 
 struct IOUtil::Impl
 {
   struct FixedReaderOptionsFunctor : public ReaderOptionsFunctorBase
   {
     FixedReaderOptionsFunctor(const IFileReader::Options& options)
       : m_Options(options)
     {}
 
     virtual bool operator()(LoadInfo& loadInfo)
     {
       IFileReader* reader = loadInfo.m_ReaderSelector.GetSelected().GetReader();
       if (reader)
       {
         reader->SetOptions(m_Options);
       }
       return false;
     }
 
   private:
     const IFileReader::Options& m_Options;
   };
 
   struct FixedWriterOptionsFunctor : public WriterOptionsFunctorBase
   {
     FixedWriterOptionsFunctor(const IFileReader::Options& options)
       : m_Options(options)
     {}
 
     virtual bool operator()(SaveInfo& saveInfo)
     {
       IFileWriter* writer = saveInfo.m_WriterSelector.GetSelected().GetWriter();
       if (writer)
       {
         writer->SetOptions(m_Options);
       }
       return false;
     }
 
   private:
     const IFileWriter::Options& m_Options;
   };
 
   static BaseData::Pointer LoadBaseDataFromFile(const std::string& path);
 
   static void SetDefaultDataNodeProperties(mitk::DataNode* node, const std::string& filePath = std::string());
 };
 
 #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
 
 char IOUtil::GetDirectorySeparator()
 {
 #ifdef US_PLATFORM_WINDOWS
   return '\\';
 #else
   return '/';
 #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(const std::string& templateName, std::string path)
 {
   ofstream tmpOutputStream;
   std::string returnValue = CreateTemporaryFile(tmpOutputStream,templateName,path);
   tmpOutputStream.close();
   return returnValue;
 }
 
 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 += GetDirectorySeparator() + 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 += GetDirectorySeparator() + 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;
 }
 
 DataStorage::SetOfObjects::Pointer IOUtil::Load(const std::string& path, DataStorage& storage)
 {
   std::vector<std::string> paths;
   paths.push_back(path);
   return Load(paths, storage);
 }
 
 DataStorage::SetOfObjects::Pointer IOUtil::Load(const std::string& path,
                                                 const IFileReader::Options& options,
                                                 DataStorage& storage)
 {
   std::vector<LoadInfo> loadInfos;
   loadInfos.push_back(LoadInfo(path));
   DataStorage::SetOfObjects::Pointer nodeResult = DataStorage::SetOfObjects::New();
   Impl::FixedReaderOptionsFunctor optionsCallback(options);
   std::string errMsg = Load(loadInfos, nodeResult, &storage, &optionsCallback);
   if (!errMsg.empty())
   {
     mitkThrow() << errMsg;
   }
   return nodeResult;
 }
 
 std::vector<BaseData::Pointer> IOUtil::Load(const std::string& path)
 {
   std::vector<std::string> paths;
   paths.push_back(path);
   return Load(paths);
 }
 
 std::vector<BaseData::Pointer> IOUtil::Load(const std::string& path, const IFileReader::Options& options)
 {
   std::vector<LoadInfo> loadInfos;
   loadInfos.push_back(LoadInfo(path));
   Impl::FixedReaderOptionsFunctor optionsCallback(options);
   std::string errMsg = Load(loadInfos, NULL, NULL, &optionsCallback);
   if (!errMsg.empty())
   {
     mitkThrow() << errMsg;
   }
   return loadInfos.front().m_Output;
 }
 
 DataStorage::SetOfObjects::Pointer IOUtil::Load(const std::vector<std::string>& paths, DataStorage& storage)
 {
   DataStorage::SetOfObjects::Pointer nodeResult = DataStorage::SetOfObjects::New();
   std::vector<LoadInfo> loadInfos;
   for (std::vector<std::string>::const_iterator iter = paths.begin(), iterEnd = paths.end();
        iter != iterEnd; ++iter)
   {
     LoadInfo loadInfo(*iter);
     loadInfos.push_back(loadInfo);
   }
   std::string errMsg = Load(loadInfos, nodeResult, &storage, NULL);
   if (!errMsg.empty())
   {
     mitkThrow() << errMsg;
   }
   return nodeResult;
 }
 
 std::vector<BaseData::Pointer> IOUtil::Load(const std::vector<std::string>& paths)
 {
   std::vector<BaseData::Pointer> result;
   std::vector<LoadInfo> loadInfos;
   for (std::vector<std::string>::const_iterator iter = paths.begin(), iterEnd = paths.end();
        iter != iterEnd; ++iter)
   {
     LoadInfo loadInfo(*iter);
     loadInfos.push_back(loadInfo);
   }
   std::string errMsg = Load(loadInfos, NULL, NULL, NULL);
   if (!errMsg.empty())
   {
     mitkThrow() << errMsg;
   }
 
   for (std::vector<LoadInfo>::const_iterator iter = loadInfos.begin(), iterEnd = loadInfos.end();
        iter != iterEnd; ++iter)
   {
     result.insert(result.end(), iter->m_Output.begin(), iter->m_Output.end());
   }
   return result;
 }
 
 int IOUtil::LoadFiles(const std::vector<std::string> &fileNames, DataStorage& ds)
 {
   return static_cast<int>(Load(fileNames, ds)->Size());
 }
 
 DataStorage::Pointer IOUtil::LoadFiles(const std::vector<std::string>& fileNames)
 {
   mitk::StandaloneDataStorage::Pointer ds = mitk::StandaloneDataStorage::New();
   Load(fileNames, *ds);
   return ds.GetPointer();
 }
 
 BaseData::Pointer IOUtil::LoadBaseData(const std::string& path)
 {
   return Impl::LoadBaseDataFromFile(path);
 }
 
 BaseData::Pointer IOUtil::Impl::LoadBaseDataFromFile(const std::string& path)
 {
   std::vector<BaseData::Pointer> baseDataList = Load(path);
 
   // The Load(path) call above should throw an exception if nothing could be loaded
   assert(!baseDataList.empty());
   return baseDataList.front();
 }
 
 DataNode::Pointer IOUtil::LoadDataNode(const std::string& path)
 {
   BaseData::Pointer baseData = Impl::LoadBaseDataFromFile(path);
 
   mitk::DataNode::Pointer node = mitk::DataNode::New();
   node->SetData(baseData);
   Impl::SetDefaultDataNodeProperties(node, path);
 
   return node;
 }
 
 Image::Pointer IOUtil::LoadImage(const std::string& path)
 {
   BaseData::Pointer baseData = Impl::LoadBaseDataFromFile(path);
   mitk::Image::Pointer image = dynamic_cast<mitk::Image*>(baseData.GetPointer());
   if(image.IsNull())
   {
     mitkThrow() << path << " is not a mitk::Image but a " << baseData->GetNameOfClass();
   }
   return image;
 }
 
 Surface::Pointer IOUtil::LoadSurface(const std::string& path)
 {
   BaseData::Pointer baseData = Impl::LoadBaseDataFromFile(path);
   mitk::Surface::Pointer surface = dynamic_cast<mitk::Surface*>(baseData.GetPointer());
   if(surface.IsNull())
   {
     mitkThrow() << path << " is not a mitk::Surface but a " << baseData->GetNameOfClass();
   }
   return surface;
 }
 
 PointSet::Pointer IOUtil::LoadPointSet(const std::string& path)
 {
   BaseData::Pointer baseData = Impl::LoadBaseDataFromFile(path);
   mitk::PointSet::Pointer pointset = dynamic_cast<mitk::PointSet*>(baseData.GetPointer());
   if(pointset.IsNull())
   {
     mitkThrow() << path << " is not a mitk::PointSet but a " << baseData->GetNameOfClass();
   }
   return pointset;
 }
 
 std::string IOUtil::Load(std::vector<LoadInfo>& loadInfos,
                          DataStorage::SetOfObjects* nodeResult, DataStorage* ds,
                          ReaderOptionsFunctorBase* optionsCallback)
 {
   if (loadInfos.empty())
   {
     return "No input files given";
   }
 
   int filesToRead = loadInfos.size();
   mitk::ProgressBar::GetInstance()->AddStepsToDo(2*filesToRead);
 
   std::string errMsg;
 
   std::map<std::string, FileReaderSelector::Item> usedReaderItems;
 
   for(std::vector<LoadInfo>::iterator infoIter = loadInfos.begin(),
       infoIterEnd = loadInfos.end(); infoIter != infoIterEnd; ++infoIter)
   {
     std::vector<FileReaderSelector::Item> readers = infoIter->m_ReaderSelector.Get();
 
     if (readers.empty())
     {
-      errMsg += "No reader available for '" + infoIter->m_Path + "'\n";
+      if (!itksys::SystemTools::FileExists(infoIter->m_Path.c_str()))
+      {
+        errMsg += "File '" + infoIter->m_Path + "' does not exist\n";
+      }
+      else
+      {
+        errMsg += "No reader available for '" + infoIter->m_Path + "'\n";
+      }
       continue;
     }
 
     bool callOptionsCallback = readers.size() > 1 || !readers.front().GetReader()->GetOptions().empty();
 
     // check if we already used a reader which should be re-used
     std::vector<MimeType> currMimeTypes = infoIter->m_ReaderSelector.GetMimeTypes();
     std::string selectedMimeType;
     for (std::vector<MimeType>::const_iterator mimeTypeIter = currMimeTypes.begin(),
          mimeTypeIterEnd = currMimeTypes.end(); mimeTypeIter != mimeTypeIterEnd; ++mimeTypeIter)
     {
       std::map<std::string, FileReaderSelector::Item>::const_iterator oldSelectedItemIter =
           usedReaderItems.find(mimeTypeIter->GetName());
       if (oldSelectedItemIter != usedReaderItems.end())
       {
         // we found an already used item for a mime-type which is contained
         // in the current reader set, check all current readers if there service
         // id equals the old reader
         for (std::vector<FileReaderSelector::Item>::const_iterator currReaderItem = readers.begin(),
              currReaderItemEnd = readers.end(); currReaderItem != currReaderItemEnd; ++currReaderItem)
         {
           if (currReaderItem->GetMimeType().GetName() == mimeTypeIter->GetName() &&
               currReaderItem->GetServiceId() == oldSelectedItemIter->second.GetServiceId() &&
               currReaderItem->GetConfidenceLevel() >= oldSelectedItemIter->second.GetConfidenceLevel())
           {
             // okay, we used the same reader already, re-use its options
             selectedMimeType = mimeTypeIter->GetName();
             callOptionsCallback = false;
             infoIter->m_ReaderSelector.Select(oldSelectedItemIter->second.GetServiceId());
             infoIter->m_ReaderSelector.GetSelected().GetReader()->SetOptions(
                   oldSelectedItemIter->second.GetReader()->GetOptions());
             break;
           }
         }
         if (!selectedMimeType.empty()) break;
       }
     }
 
     if (callOptionsCallback && optionsCallback)
     {
       callOptionsCallback = (*optionsCallback)(*infoIter);
       if (!callOptionsCallback && !infoIter->m_Cancel)
       {
         usedReaderItems.erase(selectedMimeType);
         FileReaderSelector::Item selectedItem = infoIter->m_ReaderSelector.GetSelected();
         usedReaderItems.insert(std::make_pair(selectedItem.GetMimeType().GetName(),
                                               selectedItem));
       }
     }
 
     if (infoIter->m_Cancel)
     {
       errMsg += "Reading operation(s) cancelled.";
       break;
     }
 
     IFileReader* reader = infoIter->m_ReaderSelector.GetSelected().GetReader();
     if (reader == NULL)
     {
       errMsg += "Unexpected NULL reader.";
       break;
     }
 
     // Do the actual reading
     try
     {
       DataStorage::SetOfObjects::Pointer nodes;
       if (ds != NULL)
       {
         nodes = reader->Read(*ds);
       }
       else
       {
         nodes = DataStorage::SetOfObjects::New();
         std::vector<mitk::BaseData::Pointer> baseData = reader->Read();
         for (std::vector<mitk::BaseData::Pointer>::iterator iter = baseData.begin();
              iter != baseData.end(); ++iter)
         {
           if (iter->IsNotNull())
           {
             mitk::DataNode::Pointer node = mitk::DataNode::New();
             node->SetData(*iter);
             nodes->InsertElement(nodes->Size(), node);
           }
         }
       }
 
       for (DataStorage::SetOfObjects::ConstIterator nodeIter = nodes->Begin(),
            nodeIterEnd = nodes->End(); nodeIter != nodeIterEnd; ++nodeIter)
       {
         const mitk::DataNode::Pointer& node = nodeIter->Value();
         mitk::BaseData::Pointer data = node->GetData();
         if (data.IsNull())
         {
           continue;
         }
 
         mitk::StringProperty::Pointer pathProp = mitk::StringProperty::New(infoIter->m_Path);
         data->SetProperty("path", pathProp);
 
         infoIter->m_Output.push_back(data);
         if (nodeResult)
         {
           nodeResult->push_back(nodeIter->Value());
         }
       }
 
       if (infoIter->m_Output.empty() || (nodeResult && nodeResult->Size() == 0))
       {
         errMsg += "Unknown read error occurred reading " + infoIter->m_Path;
       }
     }
     catch (const std::exception& e)
     {
       errMsg += "Exception occured when reading file " + infoIter->m_Path + ":\n" + e.what() + "\n\n";
     }
     mitk::ProgressBar::GetInstance()->Progress(2);
     --filesToRead;
   }
 
   if (!errMsg.empty())
   {
     MITK_ERROR << errMsg;
   }
 
   mitk::ProgressBar::GetInstance()->Progress(2*filesToRead);
 
   return errMsg;
 }
 
 void IOUtil::Save(const BaseData* data, const std::string& path)
 {
   Save(data, path, IFileWriter::Options());
 }
 
 void IOUtil::Save(const BaseData* data, const std::string& path, const IFileWriter::Options& options)
 {
   Save(data, std::string(), path, options);
 }
 
 void IOUtil::Save(const BaseData* data, const std::string& mimeType, const std::string& path,
                   bool addExtension)
 {
   Save(data, mimeType, path, IFileWriter::Options(), addExtension);
 }
 
 void IOUtil::Save(const BaseData* data, const std::string& mimeType, const std::string& path,
                   const IFileWriter::Options& options, bool addExtension)
 {
   std::string errMsg;
   if (options.empty())
   {
     errMsg = Save(data, mimeType, path, NULL, addExtension);
   }
   else
   {
     Impl::FixedWriterOptionsFunctor optionsCallback(options);
     errMsg = Save(data, mimeType, path, &optionsCallback, addExtension);
   }
 
   if (!errMsg.empty())
   {
     mitkThrow() << errMsg;
   }
 }
 
 void IOUtil::Save(std::vector<IOUtil::SaveInfo>& saveInfos)
 {
   std::string errMsg = Save(saveInfos, NULL);
   if (!errMsg.empty())
   {
     mitkThrow() << errMsg;
   }
 }
 
 bool IOUtil::SaveImage(mitk::Image::Pointer image, const std::string& path)
 {
   Save(image, path);
   return true;
 }
 
 bool IOUtil::SaveSurface(Surface::Pointer surface, const std::string& path)
 {
   Save(surface, path);
   return true;
 }
 
 bool IOUtil::SavePointSet(PointSet::Pointer pointset, const std::string& path)
 {
   Save(pointset, path);
   return true;
 }
 
 bool IOUtil::SaveBaseData( mitk::BaseData* data, const std::string& path)
 {
   Save(data, path);
   return true;
 }
 
 std::string IOUtil::Save(const BaseData* data, const std::string& mimeTypeName, const std::string& path,
                          WriterOptionsFunctorBase* optionsCallback, bool addExtension)
 {
   if (path.empty())
   {
     return "No output filename given";
   }
 
   mitk::CoreServicePointer<mitk::IMimeTypeProvider> mimeTypeProvider(mitk::CoreServices::GetMimeTypeProvider());
 
   MimeType mimeType = mimeTypeProvider->GetMimeTypeForName(mimeTypeName);
 
   SaveInfo saveInfo(data, mimeType, path);
 
   std::string ext = itksys::SystemTools::GetFilenameExtension(path);
 
   if (saveInfo.m_WriterSelector.IsEmpty())
   {
     return std::string("No suitable writer found for the current data of type ") + data->GetNameOfClass() +
         (mimeType.IsValid() ? (std::string(" and mime-type ") + mimeType.GetName()) : std::string()) +
         (ext.empty() ? std::string() : (std::string(" with extension ") + ext));
   }
 
   // Add an extension if not already specified
   if (ext.empty() && addExtension)
   {
     ext = saveInfo.m_MimeType.GetExtensions().empty() ? std::string() : "." + saveInfo.m_MimeType.GetExtensions().front();
   }
 
   std::vector<SaveInfo> infos;
   infos.push_back(saveInfo);
   return Save(infos, optionsCallback);
 }
 
 std::string IOUtil::Save(std::vector<SaveInfo>& saveInfos, WriterOptionsFunctorBase* optionsCallback)
 {
   if (saveInfos.empty())
   {
     return "No data for saving available";
   }
 
   int filesToWrite = saveInfos.size();
   mitk::ProgressBar::GetInstance()->AddStepsToDo(2*filesToWrite);
 
   std::string errMsg;
 
   std::set<SaveInfo> usedSaveInfos;
 
   for (std::vector<SaveInfo>::iterator infoIter = saveInfos.begin(),
        infoIterEnd = saveInfos.end(); infoIter != infoIterEnd; ++infoIter)
   {
     const std::string baseDataType = infoIter->m_BaseData->GetNameOfClass();
 
     std::vector<FileWriterSelector::Item> writers = infoIter->m_WriterSelector.Get();
 
     // Error out if no compatible Writer was found
     if (writers.empty())
     {
       errMsg += std::string("No writer available for ") + baseDataType + " data.\n";
       continue;
     }
 
     bool callOptionsCallback = writers.size() > 1 || !writers[0].GetWriter()->GetOptions().empty();
 
     // check if we already used a writer for this base data type
     // which should be re-used
     std::set<SaveInfo>::const_iterator oldSaveInfoIter = usedSaveInfos.find(*infoIter);
     if (oldSaveInfoIter != usedSaveInfos.end())
     {
       // we previously saved a base data object of the same data with the same mime-type,
       // check if the same writer is contained in the current writer set and if the
       // confidence level matches
       FileWriterSelector::Item oldSelectedItem =
           oldSaveInfoIter->m_WriterSelector.Get(oldSaveInfoIter->m_WriterSelector.GetSelectedId());
       for (std::vector<FileWriterSelector::Item>::const_iterator currWriterItem = writers.begin(),
            currWriterItemEnd = writers.end(); currWriterItem != currWriterItemEnd; ++currWriterItem)
       {
         if (currWriterItem->GetServiceId() == oldSelectedItem.GetServiceId() &&
             currWriterItem->GetConfidenceLevel() >= oldSelectedItem.GetConfidenceLevel())
         {
           // okay, we used the same writer already, re-use its options
           callOptionsCallback = false;
           infoIter->m_WriterSelector.Select(oldSaveInfoIter->m_WriterSelector.GetSelectedId());
           infoIter->m_WriterSelector.GetSelected().GetWriter()->SetOptions(
                 oldSelectedItem.GetWriter()->GetOptions());
           break;
         }
       }
     }
 
     if (callOptionsCallback && optionsCallback)
     {
       callOptionsCallback = (*optionsCallback)(*infoIter);
       if (!callOptionsCallback && !infoIter->m_Cancel)
       {
         usedSaveInfos.erase(*infoIter);
         usedSaveInfos.insert(*infoIter);
       }
     }
 
     if (infoIter->m_Cancel)
     {
       errMsg += "Writing operation(s) cancelled.";
       break;
     }
 
     IFileWriter* writer = infoIter->m_WriterSelector.GetSelected().GetWriter();
     if (writer == NULL)
     {
       errMsg += "Unexpected NULL writer.";
       break;
     }
 
     // Do the actual writing
     try
     {
       writer->SetOutputLocation(infoIter->m_Path);
       writer->Write();
     }
     catch(const std::exception& e)
     {
       errMsg += std::string("Exception occurred when writing to ") + infoIter->m_Path + ":\n" + e.what() + "\n";
     }
     mitk::ProgressBar::GetInstance()->Progress(2);
     --filesToWrite;
   }
 
   if (!errMsg.empty())
   {
     MITK_ERROR << errMsg;
   }
 
   mitk::ProgressBar::GetInstance()->Progress(2*filesToWrite);
 
   return errMsg;
 }
 
 // This method can be removed after the deprecated LoadDataNode() method was removed
 void IOUtil::Impl::SetDefaultDataNodeProperties(DataNode* node, const std::string& filePath)
 {
   // path
   mitk::StringProperty::Pointer pathProp = mitk::StringProperty::New( itksys::SystemTools::GetFilenamePath(filePath) );
   node->SetProperty(StringProperty::PATH, pathProp);
 
   // name already defined?
   mitk::StringProperty::Pointer nameProp = dynamic_cast<mitk::StringProperty*>(node->GetProperty("name"));
   if(nameProp.IsNull() || (strcmp(nameProp->GetValue(),"No Name!")==0))
   {
     // name already defined in BaseData
     mitk::StringProperty::Pointer baseDataNameProp = dynamic_cast<mitk::StringProperty*>(node->GetData()->GetProperty("name").GetPointer() );
     if(baseDataNameProp.IsNull() || (strcmp(baseDataNameProp->GetValue(),"No Name!")==0))
     {
       // name neither defined in node, nor in BaseData -> name = filename
       nameProp = mitk::StringProperty::New( itksys::SystemTools::GetFilenameWithoutExtension(filePath));
       node->SetProperty("name", nameProp);
     }
     else
     {
       // name defined in BaseData!
       nameProp = mitk::StringProperty::New(baseDataNameProp->GetValue());
       node->SetProperty("name", nameProp);
     }
   }
 
   // visibility
   if(!node->GetProperty("visible"))
   {
     node->SetVisibility(true);
   }
 }
 
 IOUtil::SaveInfo::SaveInfo(const BaseData* baseData, const MimeType& mimeType,
                            const std::string& path)
   : m_BaseData(baseData)
   , m_WriterSelector(baseData, mimeType.GetName(), path)
   , m_MimeType(mimeType.IsValid() ? mimeType // use the original mime-type
                                   : (m_WriterSelector.IsEmpty() ? mimeType // no writer found, use the original invalid mime-type
                                                                 : m_WriterSelector.GetDefault().GetMimeType() // use the found default mime-type
                                                                   )
                                     )
   , m_Path(path)
   , m_Cancel(false)
 {
 }
 
 bool IOUtil::SaveInfo::operator<(const IOUtil::SaveInfo& other) const
 {
   int r = strcmp(m_BaseData->GetNameOfClass(), other.m_BaseData->GetNameOfClass());
   if (r == 0)
   {
     return m_WriterSelector.GetSelected().GetMimeType() <
         other.m_WriterSelector.GetSelected().GetMimeType();
   }
   return r < 0;
 }
 
 IOUtil::LoadInfo::LoadInfo(const std::string& path)
   : m_Path(path)
   , m_ReaderSelector(path)
   , m_Cancel(false)
 {
 }
 
 }
diff --git a/Core/Code/Internal/mitkSurfaceStlIO.cpp b/Core/Code/Internal/mitkSurfaceStlIO.cpp
index 1d0c3d7319..942d279277 100644
--- a/Core/Code/Internal/mitkSurfaceStlIO.cpp
+++ b/Core/Code/Internal/mitkSurfaceStlIO.cpp
@@ -1,161 +1,163 @@
 /*===================================================================
 
 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 "mitkSurfaceStlIO.h"
 
 #include "mitkSurface.h"
 #include "mitkIOMimeTypes.h"
 
 #include <vtkSTLReader.h>
 #include <vtkSTLWriter.h>
 #include <vtkTriangleFilter.h>
 #include <vtkPolyDataNormals.h>
 #include <vtkCleanPolyData.h>
 #include <vtkErrorCode.h>
 #include <vtkSmartPointer.h>
 
 namespace mitk {
 
 std::string SurfaceStlIO::OPTION_MERGE_POINTS()
 {
   static std::string s = "Merge points";
   return s;
 }
 
 std::string SurfaceStlIO::OPTION_TAG_SOLIDS()
 {
   static std::string s = "Tag solids";
   return s;
 }
 
 std::string SurfaceStlIO::OPTION_CLEAN()
 {
   static std::string s = "Clean poly data";
   return s;
 }
 
 SurfaceStlIO::SurfaceStlIO()
   : SurfaceVtkIO(Surface::GetStaticNameOfClass(), IOMimeTypes::STEREOLITHOGRAPHY_MIMETYPE(), "Stereolithography")
 {
   Options defaultOptions;
 
   defaultOptions[OPTION_MERGE_POINTS()] = us::Any(true);
   defaultOptions[OPTION_TAG_SOLIDS()] = us::Any(false);
   defaultOptions[OPTION_CLEAN()] = us::Any(true);
 
   this->SetDefaultReaderOptions(defaultOptions);
 
   this->RegisterService();
 }
 
 std::vector<itk::SmartPointer<BaseData> > SurfaceStlIO::Read()
 {
   Options options = this->GetReaderOptions();
 
   mitk::Surface::Pointer output = mitk::Surface::New();
 
   vtkSmartPointer<vtkSTLReader> stlReader = vtkSmartPointer<vtkSTLReader>::New();
   stlReader->SetFileName(this->GetLocalFileName().c_str());
 
   bool mergePoints = true;
   bool tagSolids = false;
   bool cleanData = true;
 
   try
   {
     mergePoints = us::any_cast<bool>(options[OPTION_MERGE_POINTS()]);
     tagSolids = us::any_cast<bool>(options[OPTION_TAG_SOLIDS()]);
     cleanData = us::any_cast<bool>(options[OPTION_CLEAN()]);
   }
   catch (const us::BadAnyCastException& e)
   {
     MITK_WARN << "Unexpected error: " << e.what();
   }
 
   stlReader->SetMerging(mergePoints);
   stlReader->SetScalarTags(tagSolids);
 
   vtkSmartPointer<vtkPolyDataNormals> normalsGenerator = vtkSmartPointer<vtkPolyDataNormals>::New();
   normalsGenerator->SetInputConnection(stlReader->GetOutputPort());
 
   vtkSmartPointer<vtkPolyDataAlgorithm> algo = normalsGenerator;
   if (cleanData)
   {
     vtkSmartPointer<vtkCleanPolyData> cleanPolyDataFilter = vtkSmartPointer<vtkCleanPolyData>::New();
     cleanPolyDataFilter->SetInputConnection(normalsGenerator->GetOutputPort());
     cleanPolyDataFilter->PieceInvariantOff();
     cleanPolyDataFilter->ConvertLinesToPointsOff();
     cleanPolyDataFilter->ConvertPolysToLinesOff();
     cleanPolyDataFilter->ConvertStripsToPolysOff();
     if (mergePoints)
     {
       cleanPolyDataFilter->PointMergingOn();
     }
     algo = cleanPolyDataFilter;
   }
   algo->Update();
 
   if (algo->GetOutput() != NULL)
   {
     vtkSmartPointer<vtkPolyData> surfaceWithNormals = algo->GetOutput();
     output->SetVtkPolyData(surfaceWithNormals);
   }
 
   std::vector<BaseData::Pointer> result;
   result.push_back(output.GetPointer());
   return result;
 }
 
 void SurfaceStlIO::Write()
 {
   ValidateOutputLocation();
 
   const Surface* input = dynamic_cast<const Surface*>(this->GetInput());
 
   const unsigned int timesteps = input->GetTimeGeometry()->CountTimeSteps();
   for(unsigned int t = 0; t < timesteps; ++t)
   {
     std::string fileName;
     vtkSmartPointer<vtkPolyData> polyData = this->GetPolyData(t, fileName);
     vtkSmartPointer<vtkTriangleFilter> triangleFilter = vtkSmartPointer<vtkTriangleFilter>::New();
     triangleFilter->SetInputData(polyData);
     vtkSmartPointer<vtkSTLWriter> writer = vtkSmartPointer<vtkSTLWriter>::New();
     writer->SetInputConnection(triangleFilter->GetOutputPort());
 
     // The vtk stl writer cannot write to streams
     LocalFile localFile(this);
     writer->SetFileName(localFile.GetFileName().c_str());
 
     if (writer->Write() == 0 || writer->GetErrorCode() != 0 )
     {
-      mitkThrow() << "Error during surface writing: " << vtkErrorCode::GetStringFromErrorCode(writer->GetErrorCode());
+      mitkThrow() << "Error during surface writing" << (writer->GetErrorCode() ?
+                                                          std::string(": ") + vtkErrorCode::GetStringFromErrorCode(writer->GetErrorCode()) :
+                                                          std::string());
     }
 
     if (this->GetOutputStream() && input->GetTimeGeometry()->CountTimeSteps() > 1)
     {
       MITK_WARN << "Writing multiple time-steps to output streams is not supported. "
                 << "Only the first time-step will be written";
       break;
     }
   }
 }
 
 SurfaceStlIO* SurfaceStlIO::IOClone() const
 {
   return new SurfaceStlIO(*this);
 }
 
 }
diff --git a/Core/Code/Internal/mitkSurfaceVtkLegacyIO.cpp b/Core/Code/Internal/mitkSurfaceVtkLegacyIO.cpp
index 844ab19665..c93cc80626 100644
--- a/Core/Code/Internal/mitkSurfaceVtkLegacyIO.cpp
+++ b/Core/Code/Internal/mitkSurfaceVtkLegacyIO.cpp
@@ -1,111 +1,113 @@
 /*===================================================================
 
 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 "mitkSurfaceVtkLegacyIO.h"
 
 #include "mitkSurface.h"
 #include "mitkIOMimeTypes.h"
 
 #include <vtkPolyDataReader.h>
 #include <vtkPolyDataWriter.h>
 #include <vtkXMLPolyDataReader.h>
 #include <vtkXMLPolyDataWriter.h>
 #include <vtkErrorCode.h>
 #include <vtkSmartPointer.h>
 
 namespace mitk {
 
 SurfaceVtkLegacyIO::SurfaceVtkLegacyIO()
   : SurfaceVtkIO(Surface::GetStaticNameOfClass(), IOMimeTypes::VTK_POLYDATA_LEGACY_MIMETYPE(), "VTK Legacy PolyData")
 {
   this->RegisterService();
 }
 
 std::vector<itk::SmartPointer<BaseData> > SurfaceVtkLegacyIO::Read()
 {
   mitk::Surface::Pointer output = mitk::Surface::New();
 
   // The legay vtk reader cannot work with input streams
   const std::string fileName = this->GetLocalFileName();
   vtkSmartPointer<vtkPolyDataReader> reader = vtkSmartPointer<vtkPolyDataReader>::New();
   reader->SetFileName(fileName.c_str());
   reader->Update();
 
   if ( reader->GetOutput() != NULL )
   {
     output->SetVtkPolyData(reader->GetOutput());
   }
   else
   {
     mitkThrow() << "vtkPolyDataReader error: " << vtkErrorCode::GetStringFromErrorCode(reader->GetErrorCode());
   }
 
   std::vector<BaseData::Pointer> result;
   result.push_back(output.GetPointer());
   return result;
 }
 
 IFileIO::ConfidenceLevel SurfaceVtkLegacyIO::GetReaderConfidenceLevel() const
 {
   if (AbstractFileIO::GetReaderConfidenceLevel() == Unsupported) return Unsupported;
   vtkSmartPointer<vtkPolyDataReader> reader = vtkSmartPointer<vtkPolyDataReader>::New();
   reader->SetFileName(this->GetLocalFileName().c_str());
   if (reader->IsFilePolyData())
   {
     return Supported;
   }
   return Unsupported;
 }
 
 void SurfaceVtkLegacyIO::Write()
 {
   ValidateOutputLocation();
 
   const Surface* input = dynamic_cast<const Surface*>(this->GetInput());
 
   const unsigned int timesteps = input->GetTimeGeometry()->CountTimeSteps();
   for(unsigned int t = 0; t < timesteps; ++t)
   {
     std::string fileName;
     vtkSmartPointer<vtkPolyData> polyData = this->GetPolyData(t, fileName);
     vtkSmartPointer<vtkPolyDataWriter> writer = vtkSmartPointer<vtkPolyDataWriter>::New();
     writer->SetInputData(polyData);
 
     // The legacy vtk poly data writer cannot write to streams
     LocalFile localFile(this);
     writer->SetFileName(localFile.GetFileName().c_str());
 
     if (writer->Write() == 0 || writer->GetErrorCode() != 0 )
     {
-      mitkThrow() << "Error during surface writing: " << vtkErrorCode::GetStringFromErrorCode(writer->GetErrorCode());
+      mitkThrow() << "Error during surface writing" << (writer->GetErrorCode() ?
+                                                          std::string(": ") + vtkErrorCode::GetStringFromErrorCode(writer->GetErrorCode()) :
+                                                          std::string());
     }
 
     if (this->GetOutputStream() && input->GetTimeGeometry()->CountTimeSteps() > 1)
     {
       MITK_WARN << "Writing multiple time-steps to output streams is not supported. "
                 << "Only the first time-step will be written";
       break;
     }
   }
 }
 
 
 SurfaceVtkLegacyIO* SurfaceVtkLegacyIO::IOClone() const
 {
   return new SurfaceVtkLegacyIO(*this);
 }
 
 }
diff --git a/Core/Code/Internal/mitkSurfaceVtkXmlIO.cpp b/Core/Code/Internal/mitkSurfaceVtkXmlIO.cpp
index 853e28389d..1b0733e20c 100644
--- a/Core/Code/Internal/mitkSurfaceVtkXmlIO.cpp
+++ b/Core/Code/Internal/mitkSurfaceVtkXmlIO.cpp
@@ -1,144 +1,151 @@
 /*===================================================================
 
 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 "mitkSurfaceVtkXmlIO.h"
 
 #include "mitkSurface.h"
 #include "mitkIOMimeTypes.h"
 
 #include <vtkXMLPolyDataReader.h>
 #include <vtkXMLPolyDataWriter.h>
 #include <vtkErrorCode.h>
 #include <vtkSmartPointer.h>
 
 namespace mitk {
 
 class VtkXMLPolyDataReader : public ::vtkXMLPolyDataReader
 {
 public:
   static VtkXMLPolyDataReader *New() { return new VtkXMLPolyDataReader(); }
   vtkTypeMacro(VtkXMLPolyDataReader,vtkXMLPolyDataReader)
 
   void SetStream(std::istream* is) { this->Stream = is; }
   std::istream* GetStream() const { return this->Stream; }
 };
 
 class VtkXMLPolyDataWriter : public ::vtkXMLPolyDataWriter
 {
 public:
   static VtkXMLPolyDataWriter *New() { return new VtkXMLPolyDataWriter(); }
   vtkTypeMacro(VtkXMLPolyDataWriter,vtkXMLPolyDataWriter)
 
   void SetStream(std::ostream* os) { this->Stream = os; }
   std::ostream* GetStream() const { return this->Stream; }
 };
 
 SurfaceVtkXmlIO::SurfaceVtkXmlIO()
   : SurfaceVtkIO(Surface::GetStaticNameOfClass(), IOMimeTypes::VTK_POLYDATA_MIMETYPE(), "VTK XML PolyData")
 {
   this->RegisterService();
 }
 
 std::vector<itk::SmartPointer<BaseData> > SurfaceVtkXmlIO::Read()
 {
   mitk::Surface::Pointer output = mitk::Surface::New();
 
   vtkSmartPointer<VtkXMLPolyDataReader> reader= vtkSmartPointer<VtkXMLPolyDataReader>::New();
   if (this->GetInputStream())
   {
     reader->SetStream(this->GetInputStream());
   }
   else
   {
     reader->SetFileName(this->GetInputLocation().c_str());
   }
   reader->Update();
 
   if (reader->GetOutput() != NULL)
   {
     output->SetVtkPolyData(reader->GetOutput());
   }
   else
   {
     mitkThrow() << "vtkXMLPolyDataReader error: " << vtkErrorCode::GetStringFromErrorCode(reader->GetErrorCode());
   }
 
   std::vector<BaseData::Pointer> result;
   result.push_back(output.GetPointer());
   return result;
 }
 
 IFileIO::ConfidenceLevel SurfaceVtkXmlIO::GetReaderConfidenceLevel() const
 {
   if (AbstractFileIO::GetReaderConfidenceLevel() == Unsupported) return Unsupported;
   if (this->GetInputStream() == NULL)
   {
     // check if the xml vtk reader can handle the file
     vtkSmartPointer<VtkXMLPolyDataReader> xmlReader = vtkSmartPointer<VtkXMLPolyDataReader>::New();
     if (xmlReader->CanReadFile(this->GetInputLocation().c_str()) != 0)
     {
       return Supported;
     }
     return Unsupported;
   }
   // in case of an input stream, VTK does not seem to have methods for
   // validating it
   return Supported;
 }
 
 void SurfaceVtkXmlIO::Write()
 {
   ValidateOutputLocation();
 
   const Surface* input = dynamic_cast<const Surface*>(this->GetInput());
 
   const unsigned int timesteps = input->GetTimeGeometry()->CountTimeSteps();
   for(unsigned int t = 0; t < timesteps; ++t)
   {
     std::string fileName;
     vtkSmartPointer<vtkPolyData> polyData = this->GetPolyData(t, fileName);
+    if (polyData.Get() == NULL)
+    {
+      mitkThrow() << "Cannot write empty surface";
+    }
+
     vtkSmartPointer<VtkXMLPolyDataWriter> writer = vtkSmartPointer<VtkXMLPolyDataWriter>::New();
     writer->SetInputData(polyData);
 
     if (this->GetOutputStream())
     {
       if (input->GetTimeGeometry()->CountTimeSteps() > 1)
       {
         MITK_WARN << "Writing multiple time-steps to output streams is not supported. "
                   << "Only the first time-step will be written";
       }
       writer->SetStream(this->GetOutputStream());
     }
     else
     {
       writer->SetFileName(fileName.c_str());
     }
 
     if (writer->Write() == 0 || writer->GetErrorCode() != 0 )
     {
-      mitkThrow() << "Error during surface writing: " << vtkErrorCode::GetStringFromErrorCode(writer->GetErrorCode());
+      mitkThrow() << "Error during surface writing" << (writer->GetErrorCode() ?
+                                                          std::string(": ") + vtkErrorCode::GetStringFromErrorCode(writer->GetErrorCode()) :
+                                                          std::string());
     }
 
     if (this->GetOutputStream()) break;
   }
 }
 
 SurfaceVtkXmlIO* SurfaceVtkXmlIO::IOClone() const
 {
   return new SurfaceVtkXmlIO(*this);
 }
 
 }
diff --git a/Core/Code/Testing/mitkIOUtilTest.cpp b/Core/Code/Testing/mitkIOUtilTest.cpp
index 3488a9cb48..dc6b7e0055 100644
--- a/Core/Code/Testing/mitkIOUtilTest.cpp
+++ b/Core/Code/Testing/mitkIOUtilTest.cpp
@@ -1,202 +1,209 @@
 /*===================================================================
 
 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 "mitkTestingMacros.h"
 #include <mitkTestingConfig.h>
 #include <mitkTestFixture.h>
 
 #include <mitkIOUtil.h>
 #include <mitkImageGenerator.h>
 
 #include <itksys/SystemTools.hxx>
 
 class mitkIOUtilTestSuite : public mitk::TestFixture
 {
   CPPUNIT_TEST_SUITE(mitkIOUtilTestSuite);
   MITK_TEST(TestTempMethods);
+  MITK_TEST(TestSaveEmptyData);
   MITK_TEST(TestLoadAndSaveImage);
   MITK_TEST(TestLoadAndSavePointSet);
   MITK_TEST(TestLoadAndSaveSurface);
   MITK_TEST(TestTempMethodsForUniqueFilenames);
   CPPUNIT_TEST_SUITE_END();
 
 private:
 
   std::string m_ImagePath;
   std::string m_SurfacePath;
   std::string m_PointSetPath;
 
 public:
 
   void setUp()
   {
     m_ImagePath = GetTestDataFilePath("Pic3D.nrrd");
     m_SurfacePath = GetTestDataFilePath("binary.stl");
     m_PointSetPath = GetTestDataFilePath("pointSet.mps");
   }
 
+  void TestSaveEmptyData()
+  {
+    mitk::Surface::Pointer data = mitk::Surface::New();
+    CPPUNIT_ASSERT_THROW(mitk::IOUtil::Save(data, "/tmp/dummy"), mitk::Exception);
+  }
+
   void TestTempMethods()
   {
     std::string tmpPath = mitk::IOUtil::GetTempPath();
     CPPUNIT_ASSERT(!tmpPath.empty());
 
     std::ofstream tmpFile;
     std::string tmpFilePath = mitk::IOUtil::CreateTemporaryFile(tmpFile);
     CPPUNIT_ASSERT(tmpFile && tmpFile.is_open());
     CPPUNIT_ASSERT(tmpFilePath.size() > tmpPath.size());
     CPPUNIT_ASSERT(tmpFilePath.substr(0, tmpPath.size()) == tmpPath);
 
     tmpFile.close();
     CPPUNIT_ASSERT(std::remove(tmpFilePath.c_str()) == 0);
 
     std::string programPath = mitk::IOUtil::GetProgramPath();
     CPPUNIT_ASSERT(!programPath.empty());
     std::ofstream tmpFile2;
     std::string tmpFilePath2 = mitk::IOUtil::CreateTemporaryFile(tmpFile2, "my-XXXXXX", programPath);
     CPPUNIT_ASSERT(tmpFile2 && tmpFile2.is_open());
     CPPUNIT_ASSERT(tmpFilePath2.size() > programPath.size());
     CPPUNIT_ASSERT(tmpFilePath2.substr(0, programPath.size()) == programPath);
     tmpFile2.close();
     CPPUNIT_ASSERT(std::remove(tmpFilePath2.c_str()) == 0);
 
     std::ofstream tmpFile3;
     std::string tmpFilePath3 = mitk::IOUtil::CreateTemporaryFile(tmpFile3, std::ios_base::binary,
       "my-XXXXXX.TXT", programPath);
     CPPUNIT_ASSERT(tmpFile3 && tmpFile3.is_open());
     CPPUNIT_ASSERT(tmpFilePath3.size() > programPath.size());
     CPPUNIT_ASSERT(tmpFilePath3.substr(0, programPath.size()) == programPath);
     CPPUNIT_ASSERT(tmpFilePath3.substr(tmpFilePath3.size() - 13, 3) == "my-");
     CPPUNIT_ASSERT(tmpFilePath3.substr(tmpFilePath3.size() - 4) == ".TXT");
     tmpFile3.close();
     //CPPUNIT_ASSERT(std::remove(tmpFilePath3.c_str()) == 0)
 
     std::string tmpFilePath4 = mitk::IOUtil::CreateTemporaryFile();
     std::ofstream file;
     file.open(tmpFilePath4.c_str());
     CPPUNIT_ASSERT_MESSAGE("Testing if file exists after CreateTemporaryFile()",file.is_open());
 
 
     CPPUNIT_ASSERT_THROW(mitk::IOUtil::CreateTemporaryFile(tmpFile2, "XX"), mitk::Exception);
 
     std::string tmpDir = mitk::IOUtil::CreateTemporaryDirectory();
     CPPUNIT_ASSERT(tmpDir.size() > tmpPath.size());
     CPPUNIT_ASSERT(tmpDir.substr(0, tmpPath.size()) == tmpPath);
     CPPUNIT_ASSERT(itksys::SystemTools::RemoveADirectory(tmpDir.c_str()));
 
     std::string tmpDir2 = mitk::IOUtil::CreateTemporaryDirectory("my-XXXXXX", programPath);
     CPPUNIT_ASSERT(tmpDir2.size() > programPath.size());
     CPPUNIT_ASSERT(tmpDir2.substr(0, programPath.size()) == programPath);
     CPPUNIT_ASSERT(itksys::SystemTools::RemoveADirectory(tmpDir2.c_str()));
   }
 
   void TestTempMethodsForUniqueFilenames()
   {
     int numberOfFiles = 100;
 
     //create 100 empty files
     std::vector<std::string> v100filenames;
     for(int i=0; i<numberOfFiles; i++) {v100filenames.push_back(mitk::IOUtil::CreateTemporaryFile());}
 
     //check if all of them are unique
     for(int i=0; i<numberOfFiles; i++) for(int j=0; j<numberOfFiles; j++)
     {
       if(i!=j)
         {
         std::stringstream message;
         message << "Checking if file " << i << " and file " << j << " are different, which should be the case because each of them should be unique.";
         CPPUNIT_ASSERT_MESSAGE(message.str(),(v100filenames.at(i)!=v100filenames.at(j)));
         }
     }
 
     //delete all the files / clean up
     for(int i=0; i<numberOfFiles; i++) {std::remove(v100filenames.at(i).c_str());}
   }
 
   void TestLoadAndSaveImage()
   {
     mitk::Image::Pointer img1 = mitk::IOUtil::LoadImage(m_ImagePath);
     CPPUNIT_ASSERT( img1.IsNotNull());
 
     std::ofstream tmpStream;
     std::string imagePath = mitk::IOUtil::CreateTemporaryFile(tmpStream, "diffpic3d-XXXXXX.nrrd");
     tmpStream.close();
     std::string imagePath2 = mitk::IOUtil::CreateTemporaryFile(tmpStream, "diffpic3d-XXXXXX.nii.gz");
     tmpStream.close();
 
     // the cases where no exception should be thrown
     CPPUNIT_ASSERT_NO_THROW(mitk::IOUtil::Save(img1, imagePath));
     CPPUNIT_ASSERT_NO_THROW(mitk::IOUtil::Save(img1.GetPointer(), imagePath2));
 
     //load data which does not exist
     CPPUNIT_ASSERT_THROW(mitk::IOUtil::LoadImage("fileWhichDoesNotExist.nrrd"), mitk::Exception);
 
     //delete the files after the test is done
     std::remove(imagePath.c_str());
     std::remove(imagePath2.c_str());
 
     mitk::Image::Pointer relativImage = mitk::ImageGenerator::GenerateGradientImage<float>(4,4,4,1);
     std::string imagePath3 = mitk::IOUtil::CreateTemporaryFile(tmpStream, "XXXXXX.nrrd");
     tmpStream.close();
     mitk::IOUtil::Save(relativImage, imagePath3);
     CPPUNIT_ASSERT_NO_THROW(mitk::IOUtil::LoadImage(imagePath3));
     std::remove(imagePath3.c_str());
   }
 
   void TestLoadAndSavePointSet()
   {
     mitk::PointSet::Pointer pointset = mitk::IOUtil::LoadPointSet(m_PointSetPath);
     CPPUNIT_ASSERT( pointset.IsNotNull());
 
     std::ofstream tmpStream;
     std::string pointSetPath = mitk::IOUtil::CreateTemporaryFile(tmpStream, "XXXXXX.mps");
     tmpStream.close();
     std::string pointSetPathWithDefaultExtension = mitk::IOUtil::CreateTemporaryFile(tmpStream, "XXXXXX.mps");
     tmpStream.close();
     std::string pointSetPathWithoutDefaultExtension = mitk::IOUtil::CreateTemporaryFile(tmpStream);
     tmpStream.close();
 
     // the cases where no exception should be thrown
     CPPUNIT_ASSERT_NO_THROW(mitk::IOUtil::Save(pointset, pointSetPathWithDefaultExtension));
 
     // test if defaultextension is inserted if no extension is present
     CPPUNIT_ASSERT_NO_THROW(mitk::IOUtil::Save(pointset, pointSetPathWithoutDefaultExtension.c_str()));
 
     //delete the files after the test is done
     std::remove(pointSetPath.c_str());
     std::remove(pointSetPathWithDefaultExtension.c_str());
     std::remove(pointSetPathWithoutDefaultExtension.c_str());
   }
 
   void TestLoadAndSaveSurface()
   {
     mitk::Surface::Pointer surface = mitk::IOUtil::LoadSurface(m_SurfacePath);
     CPPUNIT_ASSERT( surface.IsNotNull());
 
     std::ofstream tmpStream;
     std::string surfacePath = mitk::IOUtil::CreateTemporaryFile(tmpStream, "diffsurface-XXXXXX.stl");
 
     // the cases where no exception should be thrown
     CPPUNIT_ASSERT_NO_THROW(mitk::IOUtil::Save(surface, surfacePath));
 
     // test if exception is thrown as expected on unknown extsension
     CPPUNIT_ASSERT_THROW(mitk::IOUtil::Save(surface,"testSurface.xXx"), mitk::Exception);
 
     //delete the files after the test is done
     std::remove(surfacePath.c_str());
   }
 };
 
 MITK_TEST_SUITE_REGISTRATION(mitkIOUtil)