diff --git a/CMake/mitkMacroCreateExecutable.cmake b/CMake/mitkMacroCreateExecutable.cmake
index a849f7339a..23fbf25464 100644
--- a/CMake/mitkMacroCreateExecutable.cmake
+++ b/CMake/mitkMacroCreateExecutable.cmake
@@ -1,100 +1,99 @@
 ##################################################################
 #
 # MITK_CREATE_EXECUTABLE
 #
 #! Creates an executable with MITK dependencies and batch files
 #! for proper application start-up.
 #!
 #! USAGE:
 #!
 #! \code
 #! MITK_CREATE_EXECUTABLE( [<exectuableName>]
 #!     [DEPENDS <modules we need>]
 #!     [PACKAGE_DEPENDS <packages we need, like ITK, VTK, QT>]
 #!     [INCLUDE_DIRS <list of additional include directories>]
 #!     [TARGET_DEPENDS <list of additional dependencies>
 #!     [WARNINGS_AS_ERRORS]
 #! \endcode
 #!
 #! \param EXECUTABLE_NAME The name for the new executable target
 ##################################################################
 macro(mitk_create_executable)
 
   set(_macro_params
       SUBPROJECTS            # list of CDash labels
       VERSION                # version number, e.g. "1.2.0"
       INCLUDE_DIRS           # additional include dirs
       DEPENDS                # list of modules this module depends on
       PACKAGE_DEPENDS        # list of "packages" this module depends on (e.g. Qt, VTK, etc.)
       TARGET_DEPENDS         # list of CMake targets this executable should depend on
       ADDITIONAL_LIBS        # list of additional libraries linked to this executable
       FILES_CMAKE            # file name of a CMake file setting source list variables
                              # (defaults to files.cmake)
       DESCRIPTION            # a description for the executable
      )
 
   set(_macro_options
       NO_INIT                # do not create CppMicroServices initialization code
       NO_FEATURE_INFO        # do not create a feature info by calling add_feature_info()
       NO_BATCH_FILE          # do not create batch files on Windows
       WARNINGS_AS_ERRORS     # treat all compiler warnings as errors
      )
 
   MACRO_PARSE_ARGUMENTS(EXEC "${_macro_params}" "${_macro_options}" ${ARGN})
 
   set(_EXEC_OPTIONS EXECUTABLE)
   if(EXEC_NO_INIT)
     list(APPEND _EXEC_OPTIONS NO_INIT)
   endif()
   if(EXEC_WARNINGS_AS_ERRORS)
     list(APPEND _EXEC_OPTIONS WARNINGS_AS_ERRORS)
   endif()
   if(EXEC_NO_FEATURE_INFO)
     list(APPEND _EXEC_OPTIONS NO_FEATURE_INFO)
   endif()
 
   mitk_create_module(${EXEC_DEFAULT_ARGS}
                      SUBPROJECTS ${EXEC_SUBPROJECTS}
                      VERSION ${EXEC_VERSION}
                      INCLUDE_DIRS ${EXEC_INCLUDE_DIRS}
                      DEPENDS ${EXEC_DEPENDS}
                      PACKAGE_DEPENDS ${EXEC_PACKAGE_DEPENDS}
                      TARGET_DEPENDS ${EXEC_TARGET_DEPENDS}
                      ADDITIONAL_LIBS ${EXEC_ADDITIONAL_LIBS}
                      FILES_CMAKE ${EXEC_FILES_CMAKE}
                      DESCRIPTION "${DESCRIPTION}"
                      ${_EXEC_OPTIONS}
                     )
 
   set(EXECUTABLE_IS_ENABLED ${MODULE_IS_ENABLED})
   set(EXECUTABLE_TARGET ${MODULE_TARGET})
   if(MODULE_IS_ENABLED)
     # Add meta dependencies (e.g. on auto-load modules from depending modules)
     if(ALL_META_DEPENDENCIES)
       add_dependencies(${MODULE_TARGET} ${ALL_META_DEPENDENCIES})
     endif()
-    add_dependencies(${MODULE_TARGET} MitkLegacyIO)
 
     # Create batch files for Windows platforms
     if(WIN32)
       set(_batch_file_in "${CMAKE_CURRENT_SOURCE_DIR}/${MODULE_TARGET}.bat.in")
       if(NOT EXISTS "${_batch_file_in}")
         set(_batch_file_in "${MITK_CMAKE_DIR}/StartApp.bat.in")
       endif()
       if(CMAKE_RUNTIME_OUTPUT_DIRECTORY)
         set(_batch_file_out_dir "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}")
       else()
         set(_batch_file_out_dir "${CMAKE_CURRENT_BINARY_DIR}")
       endif()
       if(NOT EXEC_NO_BATCH_FILE)
         foreach(BUILD_TYPE debug release)
           mitkFunctionCreateWindowsBatchScript(
               ${_batch_file_in} ${_batch_file_out_dir}/${MODULE_TARGET}_${BUILD_TYPE}.bat
               ${BUILD_TYPE}
              )
         endforeach()
       endif()
     endif()
   endif()
 
 endmacro()
diff --git a/CMake/mitkMacroCreateModuleTests.cmake b/CMake/mitkMacroCreateModuleTests.cmake
index c1456a8107..787d53862d 100644
--- a/CMake/mitkMacroCreateModuleTests.cmake
+++ b/CMake/mitkMacroCreateModuleTests.cmake
@@ -1,148 +1,147 @@
 #
 # Create tests and testdriver for this module
 #
 # Usage: MITK_CREATE_MODULE_TESTS( [EXTRA_DRIVER_INIT init_code]  )
 #
 # EXTRA_DRIVER_INIT is inserted as c++ code in the testdriver and will be executed before each test
 #
 macro(MITK_CREATE_MODULE_TESTS)
   MACRO_PARSE_ARGUMENTS(MODULE_TEST
                         "EXTRA_DRIVER_INIT;EXTRA_DRIVER_INCLUDE;EXTRA_DEPENDS" "US_MODULE" ${ARGN})
 
   if(BUILD_TESTING AND MODULE_IS_ENABLED)
     set(OLD_MOC_H_FILES ${MOC_H_FILES})
     set(MOC_H_FILES)
     include(files.cmake)
     include_directories(.)
 
     if(DEFINED MOC_H_FILES)
       QT4_WRAP_CPP(MODULE_TEST_GENERATED_MOC_CPP ${MOC_H_FILES} OPTIONS -DBOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
     endif(DEFINED MOC_H_FILES)
 
     mitk_check_module_dependencies(MODULES ${MODULE_NAME} MitkTestingHelper ${MODULE_TEST_EXTRA_DEPENDS}
                                    PACKAGE_DEPENDENCIES_VAR package_deps)
     _link_directories_for_packages(${package_deps})
 
     set(TESTDRIVER ${MODULE_NAME}TestDriver)
     set(MODULE_TEST_EXTRA_DRIVER_INIT "${MODULE_TEST_EXTRA_DRIVER_INIT}")
 
     # Write a header file containing include directives and custom code
     # for the test driver.
     set(TESTDRIVER_EXTRA_INCLUDES )
     list(APPEND MODULE_TEST_EXTRA_DRIVER_INCLUDE "mitkLog.h")
     list(REMOVE_DUPLICATES MODULE_TEST_EXTRA_DRIVER_INCLUDE)
     foreach(_include ${MODULE_TEST_EXTRA_DRIVER_INCLUDE})
       set(TESTDRIVER_EXTRA_INCLUDES "${TESTDRIVER_EXTRA_INCLUDES}
 #include <${_include}>")
     endforeach()
     set(TESTDRIVER_EXTRA_INCLUDES "${TESTDRIVER_EXTRA_INCLUDES}
 #include <vector>
 std::vector<std::string> globalCmdLineArgs;")
     set(_extra_include_file ${CMAKE_CURRENT_BINARY_DIR}/${TESTDRIVER}_extras.h)
     configure_file(${MITK_CMAKE_DIR}/mitkTestDriverExtraIncludes.h.in ${_extra_include_file})
 
     set(CMAKE_TESTDRIVER_BEFORE_TESTMAIN "
 for (int avIndex = 1; avIndex < ac; ++avIndex) globalCmdLineArgs.push_back(av[avIndex]);
 mitk::LoggingBackend::Register();
 ${MODULE_TEST_EXTRA_DRIVER_INIT};"
 )
     set(CMAKE_TESTDRIVER_AFTER_TESTMAIN "mitk::LoggingBackend::Unregister();")
 
     create_test_sourcelist(MODULETEST_SOURCE ${MODULE_NAME}TestDriver.cpp
       ${MODULE_TESTS} ${MODULE_IMAGE_TESTS} ${MODULE_SURFACE_TESTS} ${MODULE_CUSTOM_TESTS}
       EXTRA_INCLUDE ${_extra_include_file}
     )
 
     if(MODULE_TEST_US_MODULE)
       set(testdriver_init_file )
       find_package(CppMicroServices QUIET NO_MODULE REQUIRED)
       # Create CppMicroServices initialization code
       usFunctionGenerateExecutableInit(testdriver_init_file
                                        IDENTIFIER ${TESTDRIVER}
                                       )
       list(APPEND TEST_CPP_FILES ${testdriver_init_file})
     endif()
 
     add_executable(${TESTDRIVER} ${MODULETEST_SOURCE} ${MODULE_TEST_GENERATED_MOC_CPP} ${TEST_CPP_FILES})
     mitk_use_modules(TARGET ${TESTDRIVER}
                      MODULES ${MODULE_NAME} MitkTestingHelper ${MODULE_TEST_EXTRA_DEPENDS}
                     )
 
     if(MODULE_SUBPROJECTS)
       foreach(subproject ${MODULE_SUBPROJECTS})
         add_dependencies(${subproject} ${TESTDRIVER})
       endforeach()
     endif()
 
     # Add meta dependencies (e.g. on auto-load modules from depending modules)
     if(ALL_META_DEPENDENCIES)
       add_dependencies(${TESTDRIVER} ${ALL_META_DEPENDENCIES})
     endif()
-    add_dependencies(${TESTDRIVER} MitkLegacyIO)
 
     #
     # Now tell CMake which tests should be run. This is done automatically
     # for all tests in ${KITNAME}_TESTS and ${KITNAME}_IMAGE_TESTS. The IMAGE_TESTS
     # are run for each image in the TESTIMAGES list.
     #
     foreach( test ${MODULE_TESTS} )
       get_filename_component(TName ${test} NAME_WE)
       add_test(${TName} ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${TESTDRIVER} ${TName})
       # Add labels for CDash subproject support
       if(MODULE_SUBPROJECTS)
         set_property(TEST ${TName} PROPERTY LABELS ${MODULE_SUBPROJECTS} MITK)
       endif()
     endforeach( test )
 
     foreach(image ${MODULE_TESTIMAGES} ${ADDITIONAL_TEST_IMAGES} )
       if(EXISTS ${image})
         set(IMAGE_FULL_PATH ${image})
       else(EXISTS ${image})
         # todo: maybe search other paths as well
         # yes, please in mitk/Testing/Data, too
         set(IMAGE_FULL_PATH ${MITK_DATA_DIR}/${image})
       endif(EXISTS ${image})
 
       if(EXISTS ${IMAGE_FULL_PATH})
         foreach( test ${MODULE_IMAGE_TESTS} )
           get_filename_component(TName ${test} NAME_WE)
           get_filename_component(ImageName ${IMAGE_FULL_PATH} NAME)
           add_test(${TName}_${ImageName} ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${TESTDRIVER} ${TName} ${IMAGE_FULL_PATH})
           # Add labels for CDash subproject support
           if(MODULE_SUBPROJECTS)
             set_property(TEST ${TName}_${ImageName} PROPERTY LABELS ${MODULE_SUBPROJECTS} MITK)
           endif()
         endforeach( test )
       else(EXISTS ${IMAGE_FULL_PATH})
         message("!!!!! No such file: ${IMAGE_FULL_PATH} !!!!!")
       endif(EXISTS ${IMAGE_FULL_PATH})
     endforeach( image )
 
     foreach(surface ${MODULE_TESTSURFACES} ${ADDITIONAL_TEST_SURFACES} )
       if(EXISTS ${surface})
         set(SURFACE_FULL_PATH ${surface})
       else(EXISTS ${surface})
         # todo: maybe search other paths as well
         # yes, please in mitk/Testing/Data, too
         set(SURFACE_FULL_PATH ${MITK_DATA_DIR}/${surface})
       endif(EXISTS ${surface})
 
       if(EXISTS ${SURFACE_FULL_PATH})
         foreach( test ${MODULE_SURFACE_TESTS} )
           get_filename_component(TName ${test} NAME_WE)
           get_filename_component(SurfaceName ${SURFACE_FULL_PATH} NAME)
           add_test(${TName}_${SurfaceName} ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${TESTDRIVER} ${TName} ${SURFACE_FULL_PATH})
           # Add labels for CDash subproject support
           if(MODULE_SUBPROJECTS)
             set_property(TEST ${TName}_${SurfaceName} PROPERTY LABELS ${MODULE_SUBPROJECTS} MITK)
           endif()
         endforeach( test )
       else(EXISTS ${SURFACE_FULL_PATH})
         message("!!!!! No such surface file: ${SURFACE_FULL_PATH} !!!!!")
       endif(EXISTS ${SURFACE_FULL_PATH})
     endforeach( surface )
 
     set(MOC_H_FILES ${OLD_MOC_H_FILES})
   endif(BUILD_TESTING AND MODULE_IS_ENABLED)
 
 endmacro(MITK_CREATE_MODULE_TESTS)
diff --git a/Core/Code/Internal/mitkCoreActivator.cpp b/Core/Code/Internal/mitkCoreActivator.cpp
index 475df003e3..c919b2e87b 100644
--- a/Core/Code/Internal/mitkCoreActivator.cpp
+++ b/Core/Code/Internal/mitkCoreActivator.cpp
@@ -1,443 +1,443 @@
 /*===================================================================
 
 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 "mitkCoreActivator.h"
 
 // File IO
 #include <mitkIOUtil.h>
 #include <mitkIOMimeTypes.h>
 #include <Internal/mitkItkImageIO.h>
 #include <Internal/mitkMimeTypeProvider.h>
 #include <Internal/mitkPointSetReaderService.h>
 #include <Internal/mitkPointSetWriterService.h>
 #include <Internal/mitkRawImageFileReader.h>
 #include <Internal/mitkSurfaceStlIO.h>
 #include <Internal/mitkSurfaceVtkLegacyIO.h>
 #include <Internal/mitkSurfaceVtkXmlIO.h>
 #include <Internal/mitkImageVtkXmlIO.h>
 #include <Internal/mitkImageVtkLegacyIO.h>
 
 #include <mitkFileWriter.h>
 #include "mitkLegacyFileWriterService.h"
 
 #include <itkNiftiImageIO.h>
 
 // Micro Services
 #include <usGetModuleContext.h>
 #include <usModuleInitialization.h>
 #include <usModuleActivator.h>
 #include <usModuleContext.h>
 #include <usModuleSettings.h>
 #include <usModuleEvent.h>
 #include <usModule.h>
 #include <usModuleResource.h>
 #include <usModuleResourceStream.h>
 #include <usServiceTracker.h>
 
 
 void HandleMicroServicesMessages(us::MsgType type, const char* msg)
 {
   switch (type)
   {
   case us::DebugMsg:
     MITK_DEBUG << msg;
     break;
   case us::InfoMsg:
     MITK_INFO << msg;
     break;
   case us::WarningMsg:
     MITK_WARN << msg;
     break;
   case us::ErrorMsg:
     MITK_ERROR << msg;
     break;
   }
 }
 
 void AddMitkAutoLoadPaths(const std::string& programPath)
 {
   us::ModuleSettings::AddAutoLoadPath(programPath);
 #ifdef __APPLE__
   // Walk up three directories since that is where the .dylib files are located
   // for build trees.
   std::string additionalPath = programPath;
   bool addPath = true;
   for(int i = 0; i < 3; ++i)
   {
     std::size_t index = additionalPath.find_last_of('/');
     if (index != std::string::npos)
     {
       additionalPath = additionalPath.substr(0, index);
     }
     else
     {
       addPath = false;
       break;
     }
   }
   if (addPath)
   {
     us::ModuleSettings::AddAutoLoadPath(additionalPath);
   }
 #endif
 }
 
 class ShaderRepositoryTracker : public us::ServiceTracker<mitk::IShaderRepository>
 {
 
 public:
 
   ShaderRepositoryTracker()
     : Superclass(us::GetModuleContext())
   {
   }
 
   virtual void Close()
   {
     us::GetModuleContext()->RemoveModuleListener(this, &ShaderRepositoryTracker::HandleModuleEvent);
     Superclass::Close();
   }
 
   virtual void Open()
   {
     us::GetModuleContext()->AddModuleListener(this, &ShaderRepositoryTracker::HandleModuleEvent);
     Superclass::Open();
   }
 
 private:
 
   typedef us::ServiceTracker<mitk::IShaderRepository> Superclass;
 
   TrackedType AddingService(const ServiceReferenceType &reference)
   {
     mitk::IShaderRepository* shaderRepo = Superclass::AddingService(reference);
     if (shaderRepo)
     {
       // Add all existing shaders from modules to the new shader repository.
       // If the shader repository is registered in a modules activator, the
       // GetLoadedModules() function call below will also return the module
       // which is currently registering the repository. The HandleModuleEvent
       // method contains code to avoid double registrations due to a fired
       // ModuleEvent::LOADED event after the activators Load() method finished.
       std::vector<us::Module*> modules = us::ModuleRegistry::GetLoadedModules();
       for (std::vector<us::Module*>::const_iterator iter = modules.begin(),
            endIter = modules.end(); iter != endIter; ++iter)
       {
         this->AddModuleShaderToRepository(*iter, shaderRepo);
       }
 
       m_ShaderRepositories.push_back(shaderRepo);
     }
     return shaderRepo;
   }
 
   void RemovedService(const ServiceReferenceType& /*reference*/, TrackedType tracked)
   {
     m_ShaderRepositories.erase(std::remove(m_ShaderRepositories.begin(), m_ShaderRepositories.end(), tracked),
                                m_ShaderRepositories.end());
   }
 
   void HandleModuleEvent(const us::ModuleEvent moduleEvent)
   {
     if (moduleEvent.GetType() == us::ModuleEvent::LOADED)
     {
       std::vector<mitk::IShaderRepository*> shaderRepos;
       for (std::map<mitk::IShaderRepository*, std::map<long, std::vector<int> > >::const_iterator shaderMapIter = m_ModuleIdToShaderIds.begin(),
            shaderMapEndIter = m_ModuleIdToShaderIds.end(); shaderMapIter != shaderMapEndIter; ++shaderMapIter)
       {
         if (shaderMapIter->second.find(moduleEvent.GetModule()->GetModuleId()) == shaderMapIter->second.end())
         {
           shaderRepos.push_back(shaderMapIter->first);
         }
       }
       AddModuleShadersToRepositories(moduleEvent.GetModule(), shaderRepos);
     }
     else if (moduleEvent.GetType() == us::ModuleEvent::UNLOADED)
     {
       RemoveModuleShadersFromRepositories(moduleEvent.GetModule(), m_ShaderRepositories);
     }
   }
 
   void AddModuleShadersToRepositories(us::Module* module, const std::vector<mitk::IShaderRepository*>& shaderRepos)
   {
     // search and load shader files
     std::vector<us::ModuleResource> shaderResources = module->FindResources("Shaders", "*.xml", true);
     for (std::vector<us::ModuleResource>::iterator i = shaderResources.begin();
          i != shaderResources.end(); ++i)
     {
       if (*i)
       {
         us::ModuleResourceStream rs(*i);
         for (std::vector<mitk::IShaderRepository*>::const_iterator shaderRepoIter = shaderRepos.begin(),
              shaderRepoEndIter = shaderRepos.end(); shaderRepoIter != shaderRepoEndIter; ++shaderRepoIter)
         {
           int id = (*shaderRepoIter)->LoadShader(rs, i->GetBaseName());
           if (id >= 0)
           {
             m_ModuleIdToShaderIds[*shaderRepoIter][module->GetModuleId()].push_back(id);
           }
         }
         rs.seekg(0, std::ios_base::beg);
       }
     }
   }
 
   void AddModuleShaderToRepository(us::Module* module, mitk::IShaderRepository* shaderRepo)
   {
     std::vector<mitk::IShaderRepository*> shaderRepos;
     shaderRepos.push_back(shaderRepo);
     this->AddModuleShadersToRepositories(module, shaderRepos);
   }
 
   void RemoveModuleShadersFromRepositories(us::Module* module,
                                            const std::vector<mitk::IShaderRepository*>& shaderRepos)
   {
     for (std::vector<mitk::IShaderRepository*>::const_iterator shaderRepoIter = shaderRepos.begin(),
          shaderRepoEndIter = shaderRepos.end(); shaderRepoIter != shaderRepoEndIter; ++shaderRepoIter)
     {
       std::map<long, std::vector<int> >& moduleIdToShaderIds = m_ModuleIdToShaderIds[*shaderRepoIter];
       std::map<long, std::vector<int> >::iterator shaderIdsIter =
         moduleIdToShaderIds.find(module->GetModuleId());
       if (shaderIdsIter != moduleIdToShaderIds.end())
       {
         for (std::vector<int>::iterator idIter = shaderIdsIter->second.begin();
              idIter != shaderIdsIter->second.end(); ++idIter)
         {
           (*shaderRepoIter)->UnloadShader(*idIter);
         }
         moduleIdToShaderIds.erase(shaderIdsIter);
       }
     }
   }
 
 private:
 
   // Maps to each shader repository a map containing module ids and related
   // shader registration ids
   std::map<mitk::IShaderRepository*, std::map<long, std::vector<int> > > m_ModuleIdToShaderIds;
   std::vector<mitk::IShaderRepository*> m_ShaderRepositories;
 };
 
 class FixedNiftiImageIO : public itk::NiftiImageIO
 {
 public:
 
   /** Standard class typedefs. */
   typedef FixedNiftiImageIO         Self;
   typedef itk::NiftiImageIO         Superclass;
   typedef itk::SmartPointer< Self > Pointer;
 
   /** Method for creation through the object factory. */
   itkNewMacro(Self)
 
   /** Run-time type information (and related methods). */
   itkTypeMacro(FixedNiftiImageIO, Superclass)
 
   virtual bool SupportsDimension(unsigned long dim)
   {
     return dim > 1 && dim < 5;
   }
 
 };
 
 void MitkCoreActivator::Load(us::ModuleContext* context)
 {
   // Handle messages from CppMicroServices
   us::installMsgHandler(HandleMicroServicesMessages);
 
   this->m_Context = context;
 
   // Add the current application directory to the auto-load paths.
   // This is useful for third-party executables.
   std::string programPath = mitk::IOUtil::GetProgramPath();
   if (programPath.empty())
   {
     MITK_WARN << "Could not get the program path.";
   }
   else
   {
     AddMitkAutoLoadPaths(programPath);
   }
 
   m_ShaderRepositoryTracker.reset(new ShaderRepositoryTracker);
 
   //m_RenderingManager = mitk::RenderingManager::New();
   //context->RegisterService<mitk::RenderingManager>(renderingManager.GetPointer());
   m_PlanePositionManager.reset(new mitk::PlanePositionManagerService);
   context->RegisterService<mitk::PlanePositionManagerService>(m_PlanePositionManager.get());
 
   m_PropertyAliases.reset(new mitk::PropertyAliases);
   context->RegisterService<mitk::IPropertyAliases>(m_PropertyAliases.get());
 
   m_PropertyDescriptions.reset(new mitk::PropertyDescriptions);
   context->RegisterService<mitk::IPropertyDescriptions>(m_PropertyDescriptions.get());
 
   m_PropertyExtensions.reset(new mitk::PropertyExtensions);
   context->RegisterService<mitk::IPropertyExtensions>(m_PropertyExtensions.get());
 
   m_PropertyFilters.reset(new mitk::PropertyFilters);
   context->RegisterService<mitk::IPropertyFilters>(m_PropertyFilters.get());
 
   m_MimeTypeProvider.reset(new mitk::MimeTypeProvider);
   m_MimeTypeProvider->Start();
   m_MimeTypeProviderReg = context->RegisterService<mitk::IMimeTypeProvider>(m_MimeTypeProvider.get());
 
   this->RegisterDefaultMimeTypes();
   this->RegisterItkReaderWriter();
   this->RegisterVtkReaderWriter();
 
   // Add custom Reader / Writer Services
   m_FileReaders.push_back(new mitk::PointSetReaderService());
   m_FileWriters.push_back(new mitk::PointSetWriterService());
-  m_FileReaders.push_back(new mitk::RawImageFileReader());
+  m_FileReaders.push_back(new mitk::RawImageFileReaderService());
 
   m_ShaderRepositoryTracker->Open();
 
   /*
     There IS an option to exchange ALL vtkTexture instances against vtkNeverTranslucentTextureFactory.
     This code is left here as a reminder, just in case we might need to do that some time.
 
     vtkNeverTranslucentTextureFactory* textureFactory = vtkNeverTranslucentTextureFactory::New();
     vtkObjectFactory::RegisterFactory( textureFactory );
     textureFactory->Delete();
     */
 
   this->RegisterLegacyWriter();
 }
 
 void MitkCoreActivator::Unload(us::ModuleContext* )
 {
   for(std::vector<mitk::IFileReader*>::iterator iter = m_FileReaders.begin(),
       endIter = m_FileReaders.end(); iter != endIter; ++iter)
   {
     delete *iter;
   }
 
   for(std::vector<mitk::IFileWriter*>::iterator iter = m_FileWriters.begin(),
       endIter = m_FileWriters.end(); iter != endIter; ++iter)
   {
     delete *iter;
   }
 
   for(std::vector<mitk::AbstractFileIO*>::iterator iter = m_FileIOs.begin(),
       endIter = m_FileIOs.end(); iter != endIter; ++iter)
   {
     delete *iter;
   }
 
   for(std::vector<mitk::IFileWriter*>::iterator iter = m_LegacyWriters.begin(),
       endIter = m_LegacyWriters.end(); iter != endIter; ++iter)
   {
     delete *iter;
   }
 
   // The mitk::ModuleContext* argument of the Unload() method
   // will always be 0 for the Mitk library. It makes no sense
   // to use it at this stage anyway, since all libraries which
   // know about the module system have already been unloaded.
 
   // we need to close the internal service tracker of the
   // MimeTypeProvider class here. Otherwise it
   // would hold on to the ModuleContext longer than it is
   // actually valid.
   m_MimeTypeProviderReg.Unregister();
   m_MimeTypeProvider->Stop();
 
   m_ShaderRepositoryTracker->Close();
 }
 
 void MitkCoreActivator::RegisterDefaultMimeTypes()
 {
   // Register some default mime-types
 
   std::vector<mitk::CustomMimeType> mimeTypes = mitk::IOMimeTypes::Get();
   for (std::vector<mitk::CustomMimeType>::const_iterator mimeTypeIter = mimeTypes.begin(),
        iterEnd = mimeTypes.end(); mimeTypeIter != iterEnd; ++mimeTypeIter)
   {
     m_DefaultMimeTypes.push_back(*mimeTypeIter);
     m_Context->RegisterService(&m_DefaultMimeTypes.back());
   }
 }
 
 void MitkCoreActivator::RegisterItkReaderWriter()
 {
   std::list<itk::LightObject::Pointer> allobjects =
     itk::ObjectFactoryBase::CreateAllInstance("itkImageIOBase");
   for (std::list<itk::LightObject::Pointer >::iterator i = allobjects.begin(),
        endIter = allobjects.end(); i != endIter; ++i)
   {
     itk::ImageIOBase* io = dynamic_cast<itk::ImageIOBase*>(i->GetPointer());
 
     // NiftiImageIO does not provide a correct "SupportsDimension()" methods
     // and the supported read/write extensions are not ordered correctly
     if (dynamic_cast<itk::NiftiImageIO*>(io)) continue;
 
     if (io)
     {
       m_FileIOs.push_back(new mitk::ItkImageIO(io));
     }
     else
     {
       MITK_WARN << "Error ImageIO factory did not return an ImageIOBase: "
                 << ( *i )->GetNameOfClass();
     }
   }
 
   mitk::ItkImageIO* io = new mitk::ItkImageIO(mitk::CustomMimeType(mitk::IOMimeTypes::NIFTI_MIMETYPE_NAME()),
                                               new FixedNiftiImageIO(), 0);
   m_FileIOs.push_back(io);
 }
 
 void MitkCoreActivator::RegisterVtkReaderWriter()
 {
   m_FileIOs.push_back(new mitk::SurfaceVtkXmlIO());
   m_FileIOs.push_back(new mitk::SurfaceStlIO());
   m_FileIOs.push_back(new mitk::SurfaceVtkLegacyIO());
 
   m_FileIOs.push_back(new mitk::ImageVtkXmlIO());
   m_FileIOs.push_back(new mitk::ImageVtkLegacyIO());
 }
 
 void MitkCoreActivator::RegisterLegacyWriter()
 {
   std::list<itk::LightObject::Pointer> allobjects = itk::ObjectFactoryBase::CreateAllInstance("IOWriter");
 
   for( std::list<itk::LightObject::Pointer>::iterator i = allobjects.begin();
        i != allobjects.end(); ++i)
   {
     mitk::FileWriter::Pointer io = dynamic_cast<mitk::FileWriter*>(i->GetPointer());
     if(io)
     {
       std::string description = std::string("Legacy ") + io->GetNameOfClass() + " Reader";
       mitk::IFileWriter* writer = new mitk::LegacyFileWriterService(io, description);
       m_LegacyWriters.push_back(writer);
     }
     else
     {
       MITK_ERROR << "Error IOWriter override is not of type mitk::FileWriter: "
                  << (*i)->GetNameOfClass()
                  << std::endl;
     }
   }
 }
 
 US_EXPORT_MODULE_ACTIVATOR(MitkCore, MitkCoreActivator)
 
 // Call CppMicroservices initialization code at the end of the file.
 // This especially ensures that VTK object factories have already
 // been registered (VTK initialization code is injected by implicitly
 // include VTK header files at the top of this file).
 US_INITIALIZE_MODULE("MitkCore", "MitkCore")
diff --git a/Core/Code/Internal/mitkRawImageFileReader.cpp b/Core/Code/Internal/mitkRawImageFileReader.cpp
index 7b260874f3..1a37448ac2 100644
--- a/Core/Code/Internal/mitkRawImageFileReader.cpp
+++ b/Core/Code/Internal/mitkRawImageFileReader.cpp
@@ -1,182 +1,182 @@
 /*===================================================================
 
 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 "mitkRawImageFileReader.h"
 #include "mitkITKImageImport.h"
 #include "mitkImageCast.h"
 #include "mitkIOConstants.h"
 #include "mitkIOMimeTypes.h"
 
 #include <itkImage.h>
 #include <itkRawImageIO.h>
 #include <itkImageFileReader.h>
 
-mitk::RawImageFileReader::RawImageFileReader()
+mitk::RawImageFileReaderService::RawImageFileReaderService()
   : AbstractFileReader(CustomMimeType(IOMimeTypes::RAW_MIMETYPE_NAME()), "ITK raw image reader")
 {
   Options defaultOptions;
 
   defaultOptions[IOConstants::PIXEL_TYPE()] = IOConstants::PIXEL_TYPE_USHORT();
 
   std::vector<std::string> pixelEnum;
   pixelEnum.push_back(IOConstants::PIXEL_TYPE_UCHAR());
   pixelEnum.push_back(IOConstants::PIXEL_TYPE_CHAR());
   pixelEnum.push_back(IOConstants::PIXEL_TYPE_USHORT());
   pixelEnum.push_back(IOConstants::PIXEL_TYPE_SHORT());
   pixelEnum.push_back(IOConstants::PIXEL_TYPE_UINT());
   pixelEnum.push_back(IOConstants::PIXEL_TYPE_INT());
   pixelEnum.push_back(IOConstants::PIXEL_TYPE_FLOAT());
   pixelEnum.push_back(IOConstants::PIXEL_TYPE_DOUBLE());
   defaultOptions[IOConstants::PIXEL_TYPE_ENUM()] = pixelEnum;
 
   defaultOptions[IOConstants::DIMENSION()] = std::string("3");
   std::vector<std::string> dimEnum;
   dimEnum.push_back("2");
   dimEnum.push_back("3");
   defaultOptions[IOConstants::DIMENSION_ENUM()] = dimEnum;
 
   defaultOptions[IOConstants::ENDIANNESS()] = IOConstants::ENDIANNESS_LITTLE();
   std::vector<std::string> endianEnum;
   endianEnum.push_back(IOConstants::ENDIANNESS_LITTLE());
   endianEnum.push_back(IOConstants::ENDIANNESS_BIG());
   defaultOptions[IOConstants::ENDIANNESS_ENUM()] = endianEnum;
 
   defaultOptions[IOConstants::SIZE_X()] = 0;
   defaultOptions[IOConstants::SIZE_Y()] = 0;
   defaultOptions[IOConstants::SIZE_Z()] = 0;
   //defaultOptions[IOConstants::SIZE_T()] = 0;
 
   this->SetDefaultOptions(defaultOptions);
 
   this->RegisterService();
 }
 
-mitk::RawImageFileReader::RawImageFileReader(const mitk::RawImageFileReader& other)
+mitk::RawImageFileReaderService::RawImageFileReaderService(const mitk::RawImageFileReaderService& other)
   : AbstractFileReader(other)
 {
 }
 
-std::vector<itk::SmartPointer<mitk::BaseData> > mitk::RawImageFileReader::Read()
+std::vector<itk::SmartPointer<mitk::BaseData> > mitk::RawImageFileReaderService::Read()
 {
   std::vector<mitk::BaseData::Pointer> result;
 
   const std::string path = this->GetLocalFileName();
 
   const Options options = this->GetOptions();
 
   const std::string dimensionality = options.find(IOConstants::DIMENSION())->second.ToString();
   const std::string pixelType = options.find(IOConstants::PIXEL_TYPE())->second.ToString();
 
   EndianityType endianity = options.find(IOConstants::ENDIANNESS())->second.ToString() == IOConstants::ENDIANNESS_LITTLE() ? LITTLE : BIG;
   int dimensions[4];
   dimensions[0] = us::any_cast<int>(options.find(IOConstants::SIZE_X())->second);
   dimensions[1] = us::any_cast<int>(options.find(IOConstants::SIZE_Y())->second);
   dimensions[2] = us::any_cast<int>(options.find(IOConstants::SIZE_Z())->second);
   dimensions[3] = 0 ;//us::any_cast<int>(options.find(IOConstants::SIZE_T())->second);
 
   // check file dimensionality and pixel type and perform reading according to it
   if (dimensionality == "2")
   {
     if (pixelType == IOConstants::PIXEL_TYPE_CHAR()) result.push_back(TypedRead<signed char, 2 >(path, endianity, dimensions));
     else if (pixelType == IOConstants::PIXEL_TYPE_UCHAR()) result.push_back(TypedRead<unsigned char, 2 >(path, endianity, dimensions));
     else if (pixelType == IOConstants::PIXEL_TYPE_SHORT()) result.push_back(TypedRead<signed short int, 2 >(path, endianity, dimensions));
     else if (pixelType == IOConstants::PIXEL_TYPE_USHORT()) result.push_back(TypedRead<unsigned short int, 2 >(path, endianity, dimensions));
     else if (pixelType == IOConstants::PIXEL_TYPE_UINT()) result.push_back(TypedRead<unsigned int, 2 >(path, endianity, dimensions));
     else if (pixelType == IOConstants::PIXEL_TYPE_INT()) result.push_back(TypedRead<signed int, 2 >(path, endianity, dimensions));
     else if (pixelType == IOConstants::PIXEL_TYPE_FLOAT()) result.push_back(TypedRead<float, 2 >(path, endianity, dimensions));
     else if (pixelType == IOConstants::PIXEL_TYPE_DOUBLE())result.push_back(TypedRead<double, 2 >(path, endianity, dimensions));
     else
     {
       MITK_INFO << "Error while reading raw file: Dimensionality or pixel type not supported or not properly set" << std::endl;
     }
    }
   else if (dimensionality == "3")
   {
     if (pixelType == IOConstants::PIXEL_TYPE_CHAR()) result.push_back(TypedRead<signed char, 3 >(path, endianity, dimensions));
     else if (pixelType == IOConstants::PIXEL_TYPE_UCHAR()) result.push_back(TypedRead<unsigned char, 3 >(path, endianity, dimensions));
     else if (pixelType == IOConstants::PIXEL_TYPE_SHORT()) result.push_back(TypedRead<signed short int, 3 >(path, endianity, dimensions));
     else if (pixelType == IOConstants::PIXEL_TYPE_USHORT()) result.push_back(TypedRead<unsigned short int, 3 >(path, endianity, dimensions));
     else if (pixelType == IOConstants::PIXEL_TYPE_UINT()) result.push_back(TypedRead<unsigned int, 3 >(path, endianity, dimensions));
     else if (pixelType == IOConstants::PIXEL_TYPE_INT()) result.push_back(TypedRead<signed int, 3 >(path, endianity, dimensions));
     else if (pixelType == IOConstants::PIXEL_TYPE_FLOAT()) result.push_back(TypedRead<float, 3 >(path, endianity, dimensions));
     else if (pixelType == IOConstants::PIXEL_TYPE_DOUBLE()) result.push_back(TypedRead<double, 3 >(path, endianity, dimensions));
     else
     {
       MITK_INFO << "Error while reading raw file: Dimensionality or pixel type not supported or not properly set" << std::endl;
     }
   }
   else
   {
     MITK_INFO << "Error while reading raw file: Dimensionality not supported" << std::endl;
   }
 
   return result;
 }
 
 template < typename TPixel, unsigned int VImageDimensions >
-mitk::BaseData::Pointer mitk::RawImageFileReader::TypedRead(const std::string& path, EndianityType endianity, int* size)
+mitk::BaseData::Pointer mitk::RawImageFileReaderService::TypedRead(const std::string& path, EndianityType endianity, int* size)
 {
   typedef itk::Image< TPixel, VImageDimensions > ImageType;
   typedef itk::ImageFileReader< ImageType > ReaderType;
   typedef itk::RawImageIO< TPixel, VImageDimensions >  IOType;
 
   typename ReaderType::Pointer reader = ReaderType::New();
   typename IOType::Pointer io = IOType::New();
 
   io->SetFileDimensionality(VImageDimensions);
 
   for (unsigned short int dim = 0; dim < VImageDimensions; ++dim)
   {
     io->SetDimensions(dim, size[dim] );
   }
 
   if (endianity == LITTLE)
   {
     io->SetByteOrderToLittleEndian();
   }
   else if (endianity == BIG)
   {
     io->SetByteOrderToBigEndian();
   }
   else
   {
     MITK_INFO << "Warning: endianity not properly set. Resulting image might be incorrect";
   }
 
   reader->SetImageIO( io );
   reader->SetFileName(path);
 
   try
   {
     reader->Update();
   }
   catch( itk::ExceptionObject & err )
   {
     MITK_ERROR <<"An error occurred during the raw image reading process: ";
     MITK_INFO << err << std::endl;
   }
 
   mitk::Image::Pointer image = mitk::Image::New();
   mitk::CastToMitkImage(reader->GetOutput(), image);
   image->SetVolume(  reader->GetOutput()->GetBufferPointer());
   return image.GetPointer();
 }
 
-mitk::RawImageFileReader*mitk::RawImageFileReader::Clone() const
+mitk::RawImageFileReaderService*mitk::RawImageFileReaderService::Clone() const
 {
-  return new RawImageFileReader(*this);
+  return new RawImageFileReaderService(*this);
 }
diff --git a/Core/Code/Internal/mitkRawImageFileReader.h b/Core/Code/Internal/mitkRawImageFileReader.h
index f71b57953e..d9501e0d6f 100644
--- a/Core/Code/Internal/mitkRawImageFileReader.h
+++ b/Core/Code/Internal/mitkRawImageFileReader.h
@@ -1,65 +1,65 @@
 /*===================================================================
 
 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 MITKRAWIMAGEFILEREADER_H_
 #define MITKRAWIMAGEFILEREADER_H_
 
 #include "mitkAbstractFileReader.h"
 
 namespace mitk
 {
 
 /**
  * The user must set the dimensionality, the dimensions and the pixel type.
  * If they are incorrect, the image will not be opened or the visualization will be incorrect.
  */
-class RawImageFileReader : public AbstractFileReader
+class RawImageFileReaderService : public AbstractFileReader
 {
 
 public:
 
   /** Supported pixel types. */
   typedef enum {UCHAR,SCHAR,USHORT,SSHORT, UINT, SINT, FLOAT, DOUBLE} IOPixelType;
 
   /** Endianity of bits. */
   typedef enum {LITTLE, BIG} EndianityType;
 
-  RawImageFileReader();
+  RawImageFileReaderService();
 
 protected:
 
-  RawImageFileReader(const RawImageFileReader& other);
+  RawImageFileReaderService(const RawImageFileReaderService& other);
 
   virtual std::vector<itk::SmartPointer<BaseData> > Read();
 
   using mitk::AbstractFileReader::Read;
 
 private:
 
   template <typename TPixel, unsigned int VImageDimensions>
   mitk::BaseData::Pointer TypedRead(const std::string& path, EndianityType endianity, int* size);
 
-  RawImageFileReader* Clone() const;
+  RawImageFileReaderService* Clone() const;
 
   /** Vector containing dimensions of image to be read. */
   itk::Vector<int, 3> m_Dimensions;
 
 };
 
 } // namespace mitk
 
 #endif /* MITKRAWIMAGEFILEREADER_H_ */