diff --git a/Modules/Core/include/mitkAbstractFileReader.h b/Modules/Core/include/mitkAbstractFileReader.h
index 462c4d96e1..130f760275 100644
--- a/Modules/Core/include/mitkAbstractFileReader.h
+++ b/Modules/Core/include/mitkAbstractFileReader.h
@@ -1,229 +1,236 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 #ifndef AbstractFileReader_H_HEADER_INCLUDED_C1E7E521
 #define AbstractFileReader_H_HEADER_INCLUDED_C1E7E521
 
 // Macro
 #include <MitkCoreExports.h>
 
 // MITK
 #include <mitkBaseData.h>
 #include <mitkIFileReader.h>
 #include <mitkMimeType.h>
 
 // Microservices
 #include <usGetModuleContext.h>
 #include <usServiceProperties.h>
 #include <usServiceRegistration.h>
 
 namespace us
 {
   struct PrototypeServiceFactory;
 }
 
 namespace mitk
 {
   class CustomMimeType;
 
   /**
    * @brief Base class for creating mitk::BaseData objects from files or streams.
    * @ingroup IO
    */
   class MITKCORE_EXPORT AbstractFileReader : public mitk::IFileReader
   {
   public:
     virtual void SetInput(const std::string &location) override;
 
     virtual void SetInput(const std::string &location, std::istream *is) override;
 
     virtual std::string GetInputLocation() const override;
 
     virtual std::istream *GetInputStream() const override;
 
     MimeType GetRegisteredMimeType() const;
 
     /**
      * @brief Reads a path or stream and creates a list of BaseData objects.
      *
      * This method must be implemented for each specific reader. Call
      * GetInputStream() first and check for a non-null stream to read from.
      * If the input stream is \c nullptr, use GetInputLocation() to read from a local
      * file-system path.
      *
      * If the reader cannot use streams directly, use GetLocalFileName() instead.
      *
      * @return The created BaseData objects.
      * @throws mitk::Exception
      *
      * @see GetLocalFileName()
      * @see IFileReader::Read()
      */
     virtual std::vector<itk::SmartPointer<BaseData>> Read() override = 0;
 
     virtual DataStorage::SetOfObjects::Pointer Read(mitk::DataStorage &ds) override;
 
     virtual ConfidenceLevel GetConfidenceLevel() const override;
 
     virtual Options GetOptions() const override;
     virtual us::Any GetOption(const std::string &name) const override;
 
     virtual void SetOptions(const Options &options) override;
     virtual void SetOption(const std::string &name, const us::Any &value) override;
 
     virtual void AddProgressCallback(const ProgressCallback &callback) override;
 
     virtual void RemoveProgressCallback(const ProgressCallback &callback) override;
 
     /**
      * Associate this reader with the MIME type returned by the current IMimeTypeProvider
      * service for the provided extension if the MIME type exists, otherwise registers
      * a new MIME type when RegisterService() is called.
      *
      * If no MIME type for \c extension is already registered, a call to RegisterService()
      * will register a new MIME type and associate this reader instance with it. The MIME
      * type id can be set via SetMimeType() or it will be auto-generated using \c extension,
      * having the form "application/vnd.mitk.<extension>".
      *
      * @param extension The file extension (without a leading period) for which a registered
      *        mime-type object is looked up and associated with this reader instance.
      * @param description A human readable description of this reader.
      */
     us::ServiceRegistration<IFileReader> RegisterService(us::ModuleContext *context = us::GetModuleContext());
     void UnregisterService();
 
+    /**
+     * @return A list of files that were loaded during the last call of Read. Has to be filled by the actual reader class.
+     */
+    std::vector< std::string > GetReadFiles();
+
   protected:
     /**
      * @brief An input stream wrapper.
      *
      * If a reader can only work with input streams, use an instance
      * of this class to either wrap the specified input stream or
      * create a new input stream based on the input location in the
      * file system.
      */
     class MITKCORE_EXPORT InputStream : public std::istream
     {
     public:
       InputStream(IFileReader *writer, std::ios_base::openmode mode = std::ios_base::in);
       ~InputStream();
 
     private:
       std::istream *m_Stream;
     };
 
     AbstractFileReader();
     ~AbstractFileReader();
 
     AbstractFileReader(const AbstractFileReader &other);
 
     /**
      * Associate this reader instance with the given MIME type.
      *
      * If \c mimeType does not provide an extension list, an already
      * registered mime-type object is used. Otherwise, the first entry in
      * the extensions list is used to construct a mime-type name and
      * register it as a new CustomMimeType service object in the default
      * implementation of RegisterMimeType().
      *
      * @param mimeType The mime type this reader can read.
      * @param description A human readable description of this reader.
      *
      * @throws std::invalid_argument if \c mimeType is empty.
      *
      * @see RegisterService
      */
     explicit AbstractFileReader(const CustomMimeType &mimeType, const std::string &description);
 
     virtual us::ServiceProperties GetServiceProperties() const;
 
     /**
      * Registers a new CustomMimeType service object.
      *
      * This method is called from RegisterService and the default implementation
      * registers a new mime-type service object if all of the following conditions
      * are true:
      *
      *  - TODO
      *
      * @param context
      * @return
      * @throws std::invalid_argument if \c context is nullptr.
      */
     virtual us::ServiceRegistration<CustomMimeType> RegisterMimeType(us::ModuleContext *context);
 
     void SetMimeType(const CustomMimeType &mimeType);
 
     /**
      * @return The mime-type this reader can handle.
      */
     const CustomMimeType *GetMimeType() const;
 
     void SetMimeTypePrefix(const std::string &prefix);
     std::string GetMimeTypePrefix() const;
 
     void SetDescription(const std::string &description);
     std::string GetDescription() const;
 
     void SetDefaultOptions(const Options &defaultOptions);
     Options GetDefaultOptions() const;
 
     /**
      * \brief Set the service ranking for this file reader.
      *
      * Default is zero and should only be chosen differently for a reason.
      * The ranking is used to determine which reader to use if several
      * equivalent readers have been found.
      * It may be used to replace a default reader from MITK in your own project.
      * E.g. if you want to use your own reader for nrrd files instead of the default,
      * implement it and give it a higher ranking than zero.
      */
     void SetRanking(int ranking);
     int GetRanking() const;
 
     /**
      * @brief Get a local file name for reading.
      *
      * This is a convenience method for readers which cannot work natively
      * with input streams. If no input stream has been been set,
      * this method just returns the result of GetLocation(). However, if
      * SetLocation(std::string, std::istream*) has been called with a non-null
      * input stream, this method writes the contents of the stream to a temporary
      * file and returns the name of the temporary file.
      *
      * The temporary file is deleted when either SetLocation(std::string, std::istream*)
      * is called again with a different input stream or the destructor of this
      * class is called.
      *
      * This method does not validate file names set via SetInput(std::string).
      *
      * @return A file path in the local file-system for reading.
      */
     std::string GetLocalFileName() const;
 
     virtual void SetDefaultDataNodeProperties(DataNode *node, const std::string &filePath);
 
+    std::vector< std::string > m_ReadFiles;
+
   private:
     AbstractFileReader &operator=(const AbstractFileReader &other);
 
     virtual mitk::IFileReader *Clone() const = 0;
 
     class Impl;
     std::unique_ptr<Impl> d;
   };
 
 } // namespace mitk
 
 #endif /* AbstractFileReader_H_HEADER_INCLUDED_C1E7E521 */
diff --git a/Modules/Core/src/IO/mitkAbstractFileReader.cpp b/Modules/Core/src/IO/mitkAbstractFileReader.cpp
index 9b556c0a9f..37e6a72bc2 100644
--- a/Modules/Core/src/IO/mitkAbstractFileReader.cpp
+++ b/Modules/Core/src/IO/mitkAbstractFileReader.cpp
@@ -1,322 +1,324 @@
 /*===================================================================
 
 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 <mitkAbstractFileReader.h>
 
 #include <mitkCustomMimeType.h>
 #include <mitkIOUtil.h>
 #include <mitkStandaloneDataStorage.h>
 
 #include <mitkFileReaderWriterBase.h>
 
 #include <usGetModuleContext.h>
 #include <usModuleContext.h>
 #include <usPrototypeServiceFactory.h>
 
 #include <itksys/SystemTools.hxx>
 
 #include <fstream>
 
 namespace mitk
 {
   AbstractFileReader::InputStream::InputStream(IFileReader *reader, std::ios_base::openmode mode)
     : std::istream(nullptr), m_Stream(nullptr)
   {
     std::istream *stream = reader->GetInputStream();
     if (stream)
     {
       this->init(stream->rdbuf());
     }
     else
     {
       m_Stream = new std::ifstream(reader->GetInputLocation().c_str(), mode);
       this->init(m_Stream->rdbuf());
     }
   }
 
   AbstractFileReader::InputStream::~InputStream() { delete m_Stream; }
   class AbstractFileReader::Impl : public FileReaderWriterBase
   {
   public:
     Impl() : FileReaderWriterBase(), m_Stream(nullptr), m_PrototypeFactory(nullptr) {}
     Impl(const Impl &other) : FileReaderWriterBase(other), m_Stream(nullptr), m_PrototypeFactory(nullptr) {}
     std::string m_Location;
     std::string m_TmpFile;
     std::istream *m_Stream;
 
     us::PrototypeServiceFactory *m_PrototypeFactory;
     us::ServiceRegistration<IFileReader> m_Reg;
   };
 
   AbstractFileReader::AbstractFileReader() : d(new Impl) {}
   AbstractFileReader::~AbstractFileReader()
   {
     UnregisterService();
 
     delete d->m_PrototypeFactory;
 
     if (!d->m_TmpFile.empty())
     {
       std::remove(d->m_TmpFile.c_str());
     }
   }
 
   AbstractFileReader::AbstractFileReader(const AbstractFileReader &other) : IFileReader(), d(new Impl(*other.d.get()))
   {
   }
 
   AbstractFileReader::AbstractFileReader(const CustomMimeType &mimeType, const std::string &description) : d(new Impl)
   {
     d->SetMimeType(mimeType);
     d->SetDescription(description);
   }
 
   ////////////////////// Reading /////////////////////////
 
   std::vector<BaseData::Pointer> AbstractFileReader::Read()
   {
     std::vector<BaseData::Pointer> result;
 
     DataStorage::Pointer ds = StandaloneDataStorage::New().GetPointer();
     this->Read(*ds);
     DataStorage::SetOfObjects::ConstPointer dataNodes = ds->GetAll();
     for (DataStorage::SetOfObjects::ConstIterator iter = dataNodes->Begin(), iterEnd = dataNodes->End();
          iter != iterEnd;
          ++iter)
     {
       result.push_back(iter.Value()->GetData());
     }
     return result;
   }
 
   DataStorage::SetOfObjects::Pointer AbstractFileReader::Read(DataStorage &ds)
   {
     DataStorage::SetOfObjects::Pointer result = DataStorage::SetOfObjects::New();
     std::vector<BaseData::Pointer> data = this->Read();
     for (std::vector<BaseData::Pointer>::iterator iter = data.begin(); iter != data.end(); ++iter)
     {
       mitk::DataNode::Pointer node = mitk::DataNode::New();
       node->SetData(*iter);
       this->SetDefaultDataNodeProperties(node, this->GetInputLocation());
       ds.Add(node);
       result->InsertElement(result->Size(), node);
     }
     return result;
   }
 
   IFileReader::ConfidenceLevel AbstractFileReader::GetConfidenceLevel() const
   {
     if (d->m_Stream)
     {
       if (*d->m_Stream)
         return Supported;
     }
     else
     {
       if (itksys::SystemTools::FileExists(this->GetInputLocation().c_str(), true))
       {
         return Supported;
       }
     }
     return Unsupported;
   }
 
   //////////// µS Registration & Properties //////////////
 
   us::ServiceRegistration<IFileReader> AbstractFileReader::RegisterService(us::ModuleContext *context)
   {
     if (d->m_PrototypeFactory)
       return us::ServiceRegistration<IFileReader>();
 
     if (context == nullptr)
     {
       context = us::GetModuleContext();
     }
 
     d->RegisterMimeType(context);
 
     if (this->GetMimeType()->GetName().empty())
     {
       MITK_WARN << "Not registering reader due to empty MIME type.";
       return us::ServiceRegistration<IFileReader>();
     }
 
     struct PrototypeFactory : public us::PrototypeServiceFactory
     {
       AbstractFileReader *const m_Prototype;
 
       PrototypeFactory(AbstractFileReader *prototype) : m_Prototype(prototype) {}
       us::InterfaceMap GetService(us::Module * /*module*/,
                                   const us::ServiceRegistrationBase & /*registration*/) override
       {
         return us::MakeInterfaceMap<IFileReader>(m_Prototype->Clone());
       }
 
       void UngetService(us::Module * /*module*/,
                         const us::ServiceRegistrationBase & /*registration*/,
                         const us::InterfaceMap &service) override
       {
         delete us::ExtractInterface<IFileReader>(service);
       }
     };
 
     d->m_PrototypeFactory = new PrototypeFactory(this);
     us::ServiceProperties props = this->GetServiceProperties();
     d->m_Reg = context->RegisterService<IFileReader>(d->m_PrototypeFactory, props);
     return d->m_Reg;
   }
 
   void AbstractFileReader::UnregisterService()
   {
     try
     {
       d->m_Reg.Unregister();
     }
     catch (const std::exception &)
     {
     }
   }
 
   us::ServiceProperties AbstractFileReader::GetServiceProperties() const
   {
     us::ServiceProperties result;
 
     result[IFileReader::PROP_DESCRIPTION()] = this->GetDescription();
     result[IFileReader::PROP_MIMETYPE()] = this->GetMimeType()->GetName();
     result[us::ServiceConstants::SERVICE_RANKING()] = this->GetRanking();
     return result;
   }
 
   us::ServiceRegistration<CustomMimeType> AbstractFileReader::RegisterMimeType(us::ModuleContext *context)
   {
     return d->RegisterMimeType(context);
   }
 
+  std::vector< std::string > AbstractFileReader::GetReadFiles(){ return m_ReadFiles; }
+
   void AbstractFileReader::SetMimeType(const CustomMimeType &mimeType) { d->SetMimeType(mimeType); }
   void AbstractFileReader::SetDescription(const std::string &description) { d->SetDescription(description); }
   void AbstractFileReader::SetRanking(int ranking) { d->SetRanking(ranking); }
   int AbstractFileReader::GetRanking() const { return d->GetRanking(); }
   std::string AbstractFileReader::GetLocalFileName() const
   {
     std::string localFileName;
     if (d->m_Stream)
     {
       if (d->m_TmpFile.empty())
       {
         // write the stream contents to temporary file
         std::string ext = itksys::SystemTools::GetFilenameExtension(this->GetInputLocation());
         std::ofstream tmpStream;
         localFileName = mitk::IOUtil::CreateTemporaryFile(
           tmpStream, std::ios_base::out | std::ios_base::trunc | std::ios_base::binary, "XXXXXX" + ext);
         tmpStream << d->m_Stream->rdbuf();
         d->m_TmpFile = localFileName;
       }
       else
       {
         localFileName = d->m_TmpFile;
       }
     }
     else
     {
       localFileName = d->m_Location;
     }
     return localFileName;
   }
 
   //////////////////////// Options ///////////////////////
 
   void AbstractFileReader::SetDefaultOptions(const IFileReader::Options &defaultOptions)
   {
     d->SetDefaultOptions(defaultOptions);
   }
 
   IFileReader::Options AbstractFileReader::GetDefaultOptions() const { return d->GetDefaultOptions(); }
   void AbstractFileReader::SetInput(const std::string &location)
   {
     d->m_Location = location;
     d->m_Stream = nullptr;
   }
 
   void AbstractFileReader::SetInput(const std::string &location, std::istream *is)
   {
     if (d->m_Stream != is && !d->m_TmpFile.empty())
     {
       std::remove(d->m_TmpFile.c_str());
       d->m_TmpFile.clear();
     }
     d->m_Location = location;
     d->m_Stream = is;
   }
 
   std::string AbstractFileReader::GetInputLocation() const { return d->m_Location; }
   std::istream *AbstractFileReader::GetInputStream() const { return d->m_Stream; }
   MimeType AbstractFileReader::GetRegisteredMimeType() const { return d->GetRegisteredMimeType(); }
   IFileReader::Options AbstractFileReader::GetOptions() const { return d->GetOptions(); }
   us::Any AbstractFileReader::GetOption(const std::string &name) const { return d->GetOption(name); }
   void AbstractFileReader::SetOptions(const Options &options) { d->SetOptions(options); }
   void AbstractFileReader::SetOption(const std::string &name, const us::Any &value) { d->SetOption(name, value); }
   ////////////////// MISC //////////////////
 
   void AbstractFileReader::AddProgressCallback(const ProgressCallback &callback) { d->AddProgressCallback(callback); }
   void AbstractFileReader::RemoveProgressCallback(const ProgressCallback &callback)
   {
     d->RemoveProgressCallback(callback);
   }
 
   ////////////////// µS related Getters //////////////////
 
   const CustomMimeType *AbstractFileReader::GetMimeType() const { return d->GetMimeType(); }
   void AbstractFileReader::SetMimeTypePrefix(const std::string &prefix) { d->SetMimeTypePrefix(prefix); }
   std::string AbstractFileReader::GetMimeTypePrefix() const { return d->GetMimeTypePrefix(); }
   std::string AbstractFileReader::GetDescription() const { return d->GetDescription(); }
   void AbstractFileReader::SetDefaultDataNodeProperties(DataNode *node, const std::string &filePath)
   {
     // path
     if (!filePath.empty())
     {
       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 = filebasename;
         nameProp = mitk::StringProperty::New(this->GetRegisteredMimeType().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);
     }
   }
 }
diff --git a/Modules/Core/src/IO/mitkIOUtil.cpp b/Modules/Core/src/IO/mitkIOUtil.cpp
index 669bb99705..263c01d3ef 100644
--- a/Modules/Core/src/IO/mitkIOUtil.cpp
+++ b/Modules/Core/src/IO/mitkIOUtil.cpp
@@ -1,1051 +1,1062 @@
 /*===================================================================
 
 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 <mitkCoreObjectFactory.h>
 #include <mitkCoreServices.h>
 #include <mitkExceptionMacro.h>
 #include <mitkFileReaderRegistry.h>
 #include <mitkFileWriterRegistry.h>
 #include <mitkIDataNodeReader.h>
 #include <mitkIMimeTypeProvider.h>
 #include <mitkProgressBar.h>
 #include <mitkStandaloneDataStorage.h>
 #include <usGetModuleContext.h>
 #include <usLDAPProp.h>
 #include <usModuleContext.h>
 #include <usModuleResource.h>
 #include <usModuleResourceStream.h>
+#include <mitkAbstractFileReader.h>
 
 // ITK
 #include <itksys/SystemTools.hxx>
 
 // VTK
 #include <vtkPolyData.h>
 #include <vtkSmartPointer.h>
 #include <vtkTriangleFilter.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,
                 nullptr,
                 dw,
                 MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
                 (LPTSTR)&lpMsgBuf,
                 0,
                 nullptr);
 
   std::string errMsg((LPCTSTR)lpMsgBuf);
 
   LocalFree(lpMsgBuf);
 
   return errMsg;
 #endif
 }
 
 #ifdef US_PLATFORM_WINDOWS
 
 #include <direct.h>
 #include <io.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, nullptr);
     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 nullptr;
   }
 
   /* 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 nullptr;
     }
     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, nullptr);
     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 nullptr;
     }
   }
 
   /* We got out of the loop because we ran out of combinations to try.  */
   errno = EEXIST;
   return nullptr;
 }
 
 //#endif
 
 //**************************************************************
 // mitk::IOUtil method definitions
 
 namespace mitk
 {
   struct IOUtil::Impl
   {
     struct FixedReaderOptionsFunctor : public ReaderOptionsFunctorBase
     {
       FixedReaderOptionsFunctor(const IFileReader::Options &options) : m_Options(options) {}
       virtual bool operator()(LoadInfo &loadInfo) const override
       {
         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) const override
       {
         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, const ReaderOptionsFunctorBase* optionsCallback = nullptr);
 
     static void SetDefaultDataNodeProperties(mitk::DataNode *node, const std::string &filePath = std::string());
   };
 
   BaseData::Pointer IOUtil::Impl::LoadBaseDataFromFile(const std::string &path,
                                                        const ReaderOptionsFunctorBase *optionsCallback)
   {
     std::vector<BaseData::Pointer> baseDataList = Load(path, optionsCallback);
 
     // The Load(path) call above should throw an exception if nothing could be loaded
     assert(!baseDataList.empty());
     return baseDataList.front();
   }
 
 #ifdef US_PLATFORM_WINDOWS
   std::string IOUtil::GetProgramPath()
   {
     char path[512];
     std::size_t index = std::string(path, GetModuleFileName(nullptr, 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 <sstream>
 #include <sys/types.h>
 #include <unistd.h>
   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 += 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) == nullptr)
     {
       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, const ReaderOptionsFunctorBase *optionsCallback)
   {
     std::vector<std::string> paths;
     paths.push_back(path);
     return Load(paths, storage, optionsCallback);
   }
 
   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, const ReaderOptionsFunctorBase *optionsCallback)
   {
     std::vector<std::string> paths;
     paths.push_back(path);
     return Load(paths, optionsCallback);
   }
 
   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, nullptr, nullptr, &optionsCallback);
     if (!errMsg.empty())
     {
       mitkThrow() << errMsg;
     }
     return loadInfos.front().m_Output;
   }
 
   DataStorage::SetOfObjects::Pointer IOUtil::Load(const std::vector<std::string> &paths, DataStorage &storage, const ReaderOptionsFunctorBase *optionsCallback)
   {
     DataStorage::SetOfObjects::Pointer nodeResult = DataStorage::SetOfObjects::New();
     std::vector<LoadInfo> loadInfos;
     for (auto loadInfo : paths)
     {
       loadInfos.push_back(loadInfo);
     }
     std::string errMsg = Load(loadInfos, nodeResult, &storage, optionsCallback);
     if (!errMsg.empty())
     {
       mitkThrow() << errMsg;
     }
     return nodeResult;
   }
 
   std::vector<BaseData::Pointer> IOUtil::Load(const std::vector<std::string> &paths, const ReaderOptionsFunctorBase *optionsCallback)
   {
     std::vector<BaseData::Pointer> result;
     std::vector<LoadInfo> loadInfos;
     for (auto loadInfo : paths)
     {
       loadInfos.push_back(loadInfo);
     }
     std::string errMsg = Load(loadInfos, nullptr, nullptr, optionsCallback);
     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;
   }
 
   Image::Pointer IOUtil::LoadImage(const std::string &path,
     const ReaderOptionsFunctorBase *optionsCallback)
   {
     BaseData::Pointer baseData = Impl::LoadBaseDataFromFile(path, optionsCallback);
     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,
     const ReaderOptionsFunctorBase *optionsCallback)
   {
     BaseData::Pointer baseData = Impl::LoadBaseDataFromFile(path, optionsCallback);
     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,
     const ReaderOptionsFunctorBase *optionsCallback)
   {
     BaseData::Pointer baseData = Impl::LoadBaseDataFromFile(path, optionsCallback);
     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,
                            const 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;
 
+    std::vector< std::string > read_files;
     for (auto &loadInfo : loadInfos)
     {
+      if(std::find(read_files.begin(), read_files.end(), loadInfo.m_Path) != read_files.end())
+        continue;
+
       std::vector<FileReaderSelector::Item> readers = loadInfo.m_ReaderSelector.Get();
 
       if (readers.empty())
       {
         if (!itksys::SystemTools::FileExists(loadInfo.m_Path.c_str()))
         {
           errMsg += "File '" + loadInfo.m_Path + "' does not exist\n";
         }
         else
         {
           errMsg += "No reader available for '" + loadInfo.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 = loadInfo.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;
               loadInfo.m_ReaderSelector.Select(oldSelectedItemIter->second.GetServiceId());
               loadInfo.m_ReaderSelector.GetSelected().GetReader()->SetOptions(
                 oldSelectedItemIter->second.GetReader()->GetOptions());
               break;
             }
           }
           if (!selectedMimeType.empty())
             break;
         }
       }
 
       if (callOptionsCallback && optionsCallback)
       {
         callOptionsCallback = (*optionsCallback)(loadInfo);
         if (!callOptionsCallback && !loadInfo.m_Cancel)
         {
           usedReaderItems.erase(selectedMimeType);
           FileReaderSelector::Item selectedItem = loadInfo.m_ReaderSelector.GetSelected();
           usedReaderItems.insert(std::make_pair(selectedItem.GetMimeType().GetName(), selectedItem));
         }
       }
 
       if (loadInfo.m_Cancel)
       {
         errMsg += "Reading operation(s) cancelled.";
         break;
       }
 
       IFileReader *reader = loadInfo.m_ReaderSelector.GetSelected().GetReader();
       if (reader == nullptr)
       {
         errMsg += "Unexpected nullptr reader.";
         break;
       }
 
       // Do the actual reading
       try
       {
         DataStorage::SetOfObjects::Pointer nodes;
         if (ds != nullptr)
         {
           nodes = reader->Read(*ds);
+
+          std::vector< std::string > new_files =  dynamic_cast<mitk::AbstractFileReader*>(reader)->GetReadFiles();
+          read_files.insert( read_files.end(), new_files.begin(), new_files.end() );
         }
         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);
             }
           }
+
+          std::vector< std::string > new_files =  dynamic_cast<mitk::AbstractFileReader*>(reader)->GetReadFiles();
+          read_files.insert( read_files.end(), new_files.begin(), new_files.end() );
         }
 
         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(loadInfo.m_Path);
           data->SetProperty("path", pathProp);
 
           loadInfo.m_Output.push_back(data);
           if (nodeResult)
           {
             nodeResult->push_back(nodeIter->Value());
           }
         }
 
         if (loadInfo.m_Output.empty() || (nodeResult && nodeResult->Size() == 0))
         {
           errMsg += "Unknown read error occurred reading " + loadInfo.m_Path;
         }
       }
       catch (const std::exception &e)
       {
         errMsg += "Exception occured when reading file " + loadInfo.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;
   }
 
   std::vector<BaseData::Pointer> IOUtil::Load(const us::ModuleResource &usResource, std::ios_base::openmode mode)
   {
     us::ModuleResourceStream resStream(usResource, mode);
 
     mitk::CoreServicePointer<mitk::IMimeTypeProvider> mimeTypeProvider(mitk::CoreServices::GetMimeTypeProvider());
     std::vector<MimeType> mimetypes = mimeTypeProvider->GetMimeTypesForFile(usResource.GetResourcePath());
 
     std::vector<mitk::BaseData::Pointer> data;
     if (mimetypes.empty())
     {
       mitkThrow() << "No mimetype for resource stream: " << usResource.GetResourcePath();
       return data;
     }
 
     mitk::FileReaderRegistry fileReaderRegistry;
     std::vector<us::ServiceReference<IFileReader>> refs = fileReaderRegistry.GetReferences(mimetypes[0]);
     if (refs.empty())
     {
       mitkThrow() << "No reader available for resource stream: " << usResource.GetResourcePath();
       return data;
     }
 
     mitk::IFileReader *reader = fileReaderRegistry.GetReader(refs[0]);
     reader->SetInput(usResource.GetResourcePath(), &resStream);
     data = reader->Read();
 
     return data;
   }
 
   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)
   {
     if ((data == nullptr) || (data->IsEmpty()))
       mitkThrow() << "BaseData cannotbe null or empty for save methods in IOUtil.h.";
 
     std::string errMsg;
     if (options.empty())
     {
       errMsg = Save(data, mimeType, path, nullptr, 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, nullptr);
     if (!errMsg.empty())
     {
       mitkThrow() << errMsg;
     }
   }
 
   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)
     {
       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 (auto &saveInfo : saveInfos)
     {
       const std::string baseDataType = saveInfo.m_BaseData->GetNameOfClass();
 
       std::vector<FileWriterSelector::Item> writers = saveInfo.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(saveInfo);
       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;
             saveInfo.m_WriterSelector.Select(oldSaveInfoIter->m_WriterSelector.GetSelectedId());
             saveInfo.m_WriterSelector.GetSelected().GetWriter()->SetOptions(oldSelectedItem.GetWriter()->GetOptions());
             break;
           }
         }
       }
 
       if (callOptionsCallback && optionsCallback)
       {
         callOptionsCallback = (*optionsCallback)(saveInfo);
         if (!callOptionsCallback && !saveInfo.m_Cancel)
         {
           usedSaveInfos.erase(saveInfo);
           usedSaveInfos.insert(saveInfo);
         }
       }
 
       if (saveInfo.m_Cancel)
       {
         errMsg += "Writing operation(s) cancelled.";
         break;
       }
 
       IFileWriter *writer = saveInfo.m_WriterSelector.GetSelected().GetWriter();
       if (writer == nullptr)
       {
         errMsg += "Unexpected nullptr writer.";
         break;
       }
 
       // Do the actual writing
       try
       {
         writer->SetOutputLocation(saveInfo.m_Path);
         writer->Write();
       }
       catch (const std::exception &e)
       {
         errMsg += std::string("Exception occurred when writing to ") + saveInfo.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/Modules/DiffusionImaging/DiffusionCore/autoload/IO/mitkDiffusionImageDicomReaderService.cpp b/Modules/DiffusionImaging/DiffusionCore/autoload/IO/mitkDiffusionImageDicomReaderService.cpp
index 6d11906b39..49635e0ee6 100644
--- a/Modules/DiffusionImaging/DiffusionCore/autoload/IO/mitkDiffusionImageDicomReaderService.cpp
+++ b/Modules/DiffusionImaging/DiffusionCore/autoload/IO/mitkDiffusionImageDicomReaderService.cpp
@@ -1,297 +1,303 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 #ifndef __mitkDiffusionImageDicomReaderService_cpp
 #define __mitkDiffusionImageDicomReaderService_cpp
 
 #include "mitkDiffusionImageDicomReaderService.h"
 
 #include <iostream>
 #include <fstream>
 
 
 // Diffusion properties
 #include <mitkGradientDirectionsProperty.h>
 #include <mitkBValueMapProperty.h>
 #include <mitkMeasurementFrameProperty.h>
 #include <mitkProperties.h>
 
 #include <itkImageRegionIterator.h>
 #include <itkMetaDataObject.h>
 #include "itksys/SystemTools.hxx"
 #include "itkImageFileReader.h"
 #include "itkMetaDataObject.h"
 #include "itkNrrdImageIO.h"
 
 #include "mitkCustomMimeType.h"
 #include "mitkDiffusionCoreIOMimeTypes.h"
 #include <mitkDiffusionDICOMFileReader.h>
 #include <mitkDICOMTagBasedSorter.h>
 #include <mitkSortByImagePositionPatient.h>
 #include <mitkDICOMSortByTag.h>
 
 #include <mitkITKImageImport.h>
 #include <mitkImageWriteAccessor.h>
 #include <mitkImageDataItem.h>
 #include <mitkIOUtil.h>
 #include <mitkLocaleSwitch.h>
 #include <itksys/Directory.hxx>
 #include <gdcmDirectory.h>
 #include <mitkStringProperty.h>
 
 namespace mitk
 {
 
 DiffusionImageDicomReaderService::
 DiffusionImageDicomReaderService(const DiffusionImageDicomReaderService & other)
   : AbstractFileReader(other)
 {
 }
 
 
 DiffusionImageDicomReaderService* DiffusionImageDicomReaderService::Clone() const
 {
   return new DiffusionImageDicomReaderService(*this);
 }
 
 
 DiffusionImageDicomReaderService::
 ~DiffusionImageDicomReaderService()
 {}
 
 DiffusionImageDicomReaderService::
 DiffusionImageDicomReaderService()
   : mitk::AbstractFileReader( CustomMimeType( mitk::DiffusionCoreIOMimeTypes::DWI_DICOM_MIMETYPE() ), mitk::DiffusionCoreIOMimeTypes::DWI_DICOM_MIMETYPE_DESCRIPTION() )
 {
   Options defaultOptions;
   defaultOptions["Load recursive"] = false;
   defaultOptions["Split mosaic"] = true;
   this->SetDefaultOptions(defaultOptions);
 
   m_ServiceReg = this->RegisterService();
 }
 
 std::vector<itk::SmartPointer<mitk::BaseData> >
 DiffusionImageDicomReaderService::Read()
 {
   return InternalRead();
 }
 
 
 std::vector<itk::SmartPointer<mitk::BaseData> > DiffusionImageDicomReaderService::InternalRead()
 {
   std::vector<itk::SmartPointer<mitk::BaseData> > result_images;
   OutputType::Pointer outputForCache = OutputType::New();
   if ( this->GetInputLocation() == "")
   {
     throw itk::ImageFileReaderException(__FILE__, __LINE__, "Sorry, the filename to be read is empty!");
   }
   else
   {
     const std::string& locale = "C";
     const std::string& currLocale = setlocale( LC_ALL, nullptr );
 
     if ( locale.compare(currLocale)!=0 )
     {
       try
       {
         setlocale(LC_ALL, locale.c_str());
       }
       catch(...)
       {
         MITK_INFO << "Could not set locale " << locale;
       }
     }
 
     try
     {
       Options options = this->GetOptions();
       bool load_recursive = us::any_cast<bool>(options["Load recursive"]);
       bool split_mosaic = us::any_cast<bool>(options["Split mosaic"]);
 
       gdcm::Directory::FilenamesType complete_list;
       std::string folderName = itksys::SystemTools::GetFilenamePath( this->GetInputLocation() );
 
       if( load_recursive )
       {
         std::string subdir_prefix = "";
 
         itksys::Directory rootdir;
         rootdir.Load( folderName.c_str() );
 
         for( unsigned int idx=0; idx<rootdir.GetNumberOfFiles(); idx++)
         {
           std::string current_path = rootdir.GetFile(idx);
           std::string directory_path = std::string(rootdir.GetPath()) + std::string("/") + current_path;
 
           MITK_INFO("dicom.loader.inputrootdir.test") << "ProbePath:   " << current_path;
           MITK_INFO("dicom.loader.inputrootdir.test") << "IsDirectory: " << itksys::SystemTools::FileIsDirectory( itksys::SystemTools::ConvertToOutputPath( directory_path.c_str() ).c_str() )
                                                       << " StartsWith: " << itksys::SystemTools::StringStartsWith( current_path.c_str(), subdir_prefix.c_str() );
 
           // test for prefix
           if( itksys::SystemTools::FileIsDirectory( itksys::SystemTools::ConvertToOutputPath( directory_path.c_str() ).c_str() )
               && itksys::SystemTools::StringStartsWith( current_path.c_str(), subdir_prefix.c_str() )
               )
           {
             gdcm::Directory d;
             d.Load( itksys::SystemTools::ConvertToOutputPath( directory_path.c_str() ) , false);
 
             MITK_INFO("dicom.load.subdir.attempt") << "In directory " << itksys::SystemTools::ConvertToOutputPath( directory_path.c_str() );
 
             const gdcm::Directory::FilenamesType &l1 = d.GetFilenames();
             const unsigned int ntotalfiles = l1.size();
 
             for( unsigned int i=0; i< ntotalfiles; i++)
+            {
               complete_list.push_back( l1.at(i) );
+              m_ReadFiles.push_back( l1.at(i) );
+            }
           }
         }
       }
       else
       {
         gdcm::Directory d;
         d.Load( folderName.c_str(), load_recursive ); // recursive !
         const gdcm::Directory::FilenamesType &l1 = d.GetFilenames();
         const unsigned int ntotalfiles = l1.size();
 
         for( unsigned int i=0; i< ntotalfiles; i++)
+        {
           complete_list.push_back( l1.at(i) );
+          m_ReadFiles.push_back( l1.at(i) );
+        }
       }
 
       mitk::DiffusionDICOMFileReader::Pointer gdcmReader = mitk::DiffusionDICOMFileReader::New();
       mitk::DICOMTagBasedSorter::Pointer tagSorter = mitk::DICOMTagBasedSorter::New();
 
       // Use tags as in Qmitk
       // all the things that split by tag in DicomSeriesReader
       tagSorter->AddDistinguishingTag( mitk::DICOMTag(0x0028, 0x0010) ); // Number of Rows
       tagSorter->AddDistinguishingTag( mitk::DICOMTag(0x0028, 0x0011) ); // Number of Columns
       tagSorter->AddDistinguishingTag( mitk::DICOMTag(0x0028, 0x0030) ); // Pixel Spacing
       tagSorter->AddDistinguishingTag( mitk::DICOMTag(0x0018, 0x1164) ); // Imager Pixel Spacing
       tagSorter->AddDistinguishingTag( mitk::DICOMTag(0x0020, 0x0037) ); // Image Orientation (Patient) // TODO add tolerance parameter (l. 1572 of original code)
       // TODO handle as real vectors! cluster with configurable errors!
       tagSorter->AddDistinguishingTag( mitk::DICOMTag(0x0020, 0x000e) ); // Series Instance UID
       tagSorter->AddDistinguishingTag( mitk::DICOMTag(0x0018, 0x0050) ); // Slice Thickness
       tagSorter->AddDistinguishingTag( mitk::DICOMTag(0x0028, 0x0008) ); // Number of Frames
       //tagSorter->AddDistinguishingTag( mitk::DICOMTag(0x0020, 0x0052) ); // Frame of Reference UID
 
       // gdcmReader->AddSortingElement( tagSorter );
       //mitk::DICOMFileReaderTestHelper::TestOutputsContainInputs( gdcmReader );
 
       mitk::DICOMSortCriterion::ConstPointer sorting =
           mitk::SortByImagePositionPatient::New(  // Image Position (Patient)
                                                   //mitk::DICOMSortByTag::New( mitk::DICOMTag(0x0020, 0x0013), // instance number
                                                   mitk::DICOMSortByTag::New( mitk::DICOMTag(0x0020, 0x0012), // aqcuisition number
                                                                              mitk::DICOMSortByTag::New( mitk::DICOMTag(0x0008, 0x0032), // aqcuisition time
                                                                                                         mitk::DICOMSortByTag::New( mitk::DICOMTag(0x0018, 0x1060), // trigger time
                                                                                                                                    mitk::DICOMSortByTag::New( mitk::DICOMTag(0x0008, 0x0018) // SOP instance UID (last resort, not really meaningful but decides clearly)
                                                                                                                                                               ).GetPointer()
                                                                                                                                    ).GetPointer()
                                                                                                         ).GetPointer()
                                                                              ).GetPointer()
                                                   // ).GetPointer()
                                                   ).GetPointer();
       tagSorter->SetSortCriterion( sorting );
 
       // mosaic
       gdcmReader->SetResolveMosaic( split_mosaic );
       gdcmReader->AddSortingElement( tagSorter );
       gdcmReader->SetInputFiles( complete_list );
       try
       {
         gdcmReader->AnalyzeInputFiles();
       }
       catch( const itk::ExceptionObject &e)
       {
         MITK_ERROR << "Failed to analyze data. " << e.what();
       }
       catch( const std::exception &se)
       {
         MITK_ERROR << "Std Exception " << se.what();
       }
 
       gdcmReader->LoadImages();
 
       for( unsigned int o = 0; o < gdcmReader->GetNumberOfOutputs(); o++ )
       {
         mitk::Image::Pointer loaded_image = gdcmReader->GetOutput(o).GetMitkImage();
 
         std::stringstream ss;
         ss << "ImportedData_" << o;
 
         StringProperty::Pointer nameProp;
         if (gdcmReader->GetSeriesName(o)!="-")
           nameProp = StringProperty::New(gdcmReader->GetSeriesName(o));
         else if (gdcmReader->GetStudyName(o)!="-")
           nameProp = StringProperty::New(gdcmReader->GetStudyName(o));
         else
           nameProp = StringProperty::New(folderName);
 
         loaded_image->SetProperty("name", nameProp);
 
         result_images.push_back(loaded_image.GetPointer());
       }
 
 
       // Since we have already read the tree, we can store it in a cache variable
       // so that it can be assigned to the DataObject in GenerateData();
       m_OutputCache = outputForCache;
       m_CacheTime.Modified();
 
       try
       {
         setlocale(LC_ALL, currLocale.c_str());
       }
       catch(...)
       {
         MITK_INFO << "Could not reset locale " << currLocale;
       }
     }
     catch(std::exception& e)
     {
       try
       {
         setlocale(LC_ALL, currLocale.c_str());
       }
       catch(...)
       {
         MITK_INFO << "Could not reset locale " << currLocale;
       }
 
       MITK_INFO << "Std::Exception while reading file!!";
       MITK_INFO << e.what();
       throw itk::ImageFileReaderException(__FILE__, __LINE__, e.what());
     }
     catch(...)
     {
       try
       {
         setlocale(LC_ALL, currLocale.c_str());
       }
       catch(...)
       {
         MITK_INFO << "Could not reset locale " << currLocale;
       }
 
       MITK_INFO << "Exception while reading file!!";
       throw itk::ImageFileReaderException(__FILE__, __LINE__, "Sorry, an error occurred while reading the requested vessel tree file!");
     }
   }
 
   return result_images;
 }
 
 } //namespace MITK
 
 #endif