diff --git a/CMakeLists.txt b/CMakeLists.txt
index b1962b7a8e..0b3d893e6c 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,478 +1,477 @@
 cmake_minimum_required(VERSION 2.8.2)
 
 #-----------------------------------------------------------------------------
 # Superbuild Option - Enabled by default
 #-----------------------------------------------------------------------------
 
 option(MITK_USE_SUPERBUILD "Build MITK and the projects it depends on via SuperBuild.cmake." ON)
 
 if(MITK_USE_SUPERBUILD)
   project(MITK-superbuild)
   set(MITK_SOURCE_DIR ${PROJECT_SOURCE_DIR})
   set(MITK_BINARY_DIR ${PROJECT_BINARY_DIR})
 else()
   project(MITK)
 endif()
 
 #-----------------------------------------------------------------------------
 # See http://cmake.org/cmake/help/cmake-2-8-docs.html#section_Policies for details
 #-----------------------------------------------------------------------------
 
 set(project_policies
   CMP0001 # NEW: CMAKE_BACKWARDS_COMPATIBILITY should no longer be used.
   CMP0002 # NEW: Logical target names must be globally unique.
   CMP0003 # NEW: Libraries linked via full path no longer produce linker search paths.
   CMP0004 # NEW: Libraries linked may NOT have leading or trailing whitespace.
   CMP0005 # NEW: Preprocessor definition values are now escaped automatically.
   CMP0006 # NEW: Installing MACOSX_BUNDLE targets requires a BUNDLE DESTINATION.
   CMP0007 # NEW: List command no longer ignores empty elements.
   CMP0008 # NEW: Libraries linked by full-path must have a valid library file name.
   CMP0009 # NEW: FILE GLOB_RECURSE calls should not follow symlinks by default.
   CMP0010 # NEW: Bad variable reference syntax is an error.
   CMP0011 # NEW: Included scripts do automatic cmake_policy PUSH and POP.
   CMP0012 # NEW: if() recognizes numbers and boolean constants.
   CMP0013 # NEW: Duplicate binary directories are not allowed.
   CMP0014 # NEW: Input directories must have CMakeLists.txt
   )
 foreach(policy ${project_policies})
   if(POLICY ${policy})
     cmake_policy(SET ${policy} NEW)
   endif()
 endforeach()
 
 #-----------------------------------------------------------------------------
 # Update CMake module path
 #------------------------------------------------------------------------------
 
 set(CMAKE_MODULE_PATH
   ${MITK_SOURCE_DIR}/CMake
   ${CMAKE_MODULE_PATH}
   )
 
 #-----------------------------------------------------------------------------
 # CMake Function(s) and Macro(s)
 #-----------------------------------------------------------------------------
 
 include(mitkMacroEmptyExternalProject)
 include(mitkFunctionGenerateProjectXml)
 
 #-----------------------------------------------------------------------------
 # Output directories.
 #-----------------------------------------------------------------------------
 
 foreach(type LIBRARY RUNTIME ARCHIVE)
   # Make sure the directory exists
   if(DEFINED MITK_CMAKE_${type}_OUTPUT_DIRECTORY
      AND NOT EXISTS ${MITK_CMAKE_${type}_OUTPUT_DIRECTORY})
     message(FATAL_ERROR "MITK_CMAKE_${type}_OUTPUT_DIRECTORY is set to a non-existing directory [${MITK_CMAKE_${type}_OUTPUT_DIRECTORY}]")
   endif()
 
   if(MITK_USE_SUPERBUILD)
     set(output_dir ${MITK_BINARY_DIR}/bin)
     if(NOT DEFINED MITK_CMAKE_${type}_OUTPUT_DIRECTORY)
       set(MITK_CMAKE_${type}_OUTPUT_DIRECTORY ${MITK_BINARY_DIR}/MITK-build/bin)
     endif()
   else()
     if(NOT DEFINED MITK_CMAKE_${type}_OUTPUT_DIRECTORY)
       SET(output_dir ${MITK_BINARY_DIR}/bin)
     else()
       SET(output_dir ${MITK_CMAKE_${type}_OUTPUT_DIRECTORY})
     endif()
   endif()
   set(CMAKE_${type}_OUTPUT_DIRECTORY ${output_dir} CACHE INTERNAL "Single output directory for building all libraries.")
   mark_as_advanced(CMAKE_${type}_OUTPUT_DIRECTORY)
 endforeach()
 
 #-----------------------------------------------------------------------------
 # Additional MITK Options (also shown during superbuild)
 #-----------------------------------------------------------------------------
 
 option(BUILD_SHARED_LIBS "Build MITK with shared libraries" ON)
 option(WITH_COVERAGE "Enable/Disable coverage" OFF)
 option(BUILD_TESTING "Test the project" ON)
 
 # some targets in Utilities also depend on Qt. Use this option
 # to decide if they should be build
 option(MITK_USE_QT "Use Trolltech's Qt library" ON)
 if(MITK_USE_QT)
   # find the package at the very beginning, so that QT4_FOUND is available
   find_package(Qt4 4.6.0 REQUIRED)
 endif()
 
 option(MITK_INSTALL_RPATH_RELATIVE "Use relative rpath entries for installation packages" OFF)
 option(MITK_BUILD_ALL_PLUGINS "Build all MITK plugins" OFF)
 option(MITK_BUILD_TUTORIAL "Build the MITK tutorial" ON)
 option(MITK_USE_Boost "Use the Boost C++ library" OFF)
-option(MITK_USE_GDCMIO "Use the GDCMIO class instead of ImageIO2 for DICOM" ON)
 option(MITK_USE_BLUEBERRY "Build the BlueBerry platform" ON)
 option(MITK_USE_CTK "EXEPERIMENTAL, superbuild only: Use CTK in MITK" OFF)
 option(MITK_USE_DCMTK "EXEPERIMENTAL, superbuild only: Use DCMTK in MITK" OFF)
 option(MITK_USE_OpenCV "Use Intel's OpenCV library" OFF)
   
 mark_as_advanced(MITK_INSTALL_RPATH_RELATIVE
                  MITK_BUILD_ALL_PLUGINS
                  MITK_USE_CTK
                  MITK_USE_DCMTK
                  )
 
 #-----------------------------------------------------------------------------
 # Additional CXX/C Flags
 #-----------------------------------------------------------------------------
 
 set(ADDITIONAL_C_FLAGS "" CACHE STRING "Additional C Flags")
 mark_as_advanced(ADDITIONAL_C_FLAGS)
 set(ADDITIONAL_CXX_FLAGS "" CACHE STRING "Additional CXX Flags")
 mark_as_advanced(ADDITIONAL_CXX_FLAGS)
 
 #-----------------------------------------------------------------------------
 # Project.xml
 #-----------------------------------------------------------------------------
 
 # A list of topologically ordered targets
 set(CTEST_PROJECT_SUBPROJECTS)
 if(MITK_USE_BLUEBERRY)
   list(APPEND CTEST_PROJECT_SUBPROJECTS BlueBerry)
 endif()
 
 list(APPEND CTEST_PROJECT_SUBPROJECTS
   MITK-Core
   MITK-CoreUI
   MITK-IGT
   MITK-ToF
   MITK-DTI
   MITK-Registration
   MITK-Modules # all modules not contained in a specific subproject
   MITK-Plugins # all plugins not contained in a specific subproject
   )
 
 # Configure CTestConfigSubProject.cmake that could be used by CTest scripts
 configure_file(${MITK_SOURCE_DIR}/CTestConfigSubProject.cmake.in
                ${MITK_BINARY_DIR}/CTestConfigSubProject.cmake)
 
 # Generate Project.xml file expected by the CTest driver script
 mitkFunctionGenerateProjectXml(${MITK_BINARY_DIR} ${PROJECT_NAME} "${CTEST_PROJECT_SUBPROJECTS}" ${MITK_USE_SUPERBUILD})
 
 #-----------------------------------------------------------------------------
 # Superbuild script
 #-----------------------------------------------------------------------------
 
 if(MITK_USE_SUPERBUILD)
   include("${CMAKE_CURRENT_SOURCE_DIR}/SuperBuild.cmake")
   return()
 endif()
 
 #*****************************************************************************
 #****************************  END OF SUPERBUILD  ****************************
 #*****************************************************************************
 
 #-----------------------------------------------------------------------------
 # CMake Function(s) and Macro(s)
 #-----------------------------------------------------------------------------
 
 include(mitkFunctionCheckCompilerFlags)
 include(mitkFunctionGetGccVersion)
 include(MacroParseArguments)
 include(mitkFunctionSuppressWarnings) # includes several functions
 include(mitkFunctionOrganizeSources)
 include(mitkFunctionGetVersion)
 include(mitkFunctionCreateWindowsBatchScript)
 include(mitkMacroCreateModuleConf)
 include(mitkMacroCreateModule)
 include(mitkMacroCheckModule)
 include(mitkMacroCreateModuleTests)
 include(mitkFunctionAddCustomModuleTest)
 include(mitkMacroUseModule)
 include(mitkMacroMultiplexPicType)
 include(mitkMacroInstall)
 include(mitkMacroInstallHelperApp)
 include(mitkMacroInstallTargets)
 include(mitkMacroGenerateToolsLibrary)
 
 #-----------------------------------------------------------------------------
 # Prerequesites
 #-----------------------------------------------------------------------------
 
 find_package(ITK REQUIRED)
 find_package(VTK REQUIRED)
 
 #-----------------------------------------------------------------------------
 # Set MITK specific options and variables (NOT available during superbuild)
 #-----------------------------------------------------------------------------
 
 # ASK THE USER TO SHOW THE CONSOLE WINDOW FOR CoreApp and ExtApp
 option(MITK_SHOW_CONSOLE_WINDOW "Use this to enable or disable the console window when starting MITK GUI Applications" ON)
 mark_as_advanced(MITK_SHOW_CONSOLE_WINDOW)
 
 # TODO: check if necessary
 option(USE_ITKZLIB "Use the ITK zlib for pic compression." ON)
 mark_as_advanced(USE_ITKZLIB)
 
 #-----------------------------------------------------------------------------
 # Get MITK version info
 #-----------------------------------------------------------------------------
 
 mitkFunctionGetVersion(${MITK_SOURCE_DIR} MITK)
 
 #-----------------------------------------------------------------------------
 # Set symbol visibility Flags
 #-----------------------------------------------------------------------------
 
 # MinGW does not export all symbols automatically, so no need to set flags
 if(CMAKE_COMPILER_IS_GNUCXX AND NOT MINGW)
   set(VISIBILITY_CXX_FLAGS ) #"-fvisibility=hidden -fvisibility-inlines-hidden")
 endif()
 
 #-----------------------------------------------------------------------------
 # Set coverage Flags
 #-----------------------------------------------------------------------------
 
 if(WITH_COVERAGE)
   if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
     set(coverage_flags "-g -fprofile-arcs -ftest-coverage -O0 -DNDEBUG")
     set(COVERAGE_CXX_FLAGS ${coverage_flags})
     set(COVERAGE_C_FLAGS ${coverage_flags})
   endif()
 endif()
 
 #-----------------------------------------------------------------------------
 # MITK C/CXX Flags
 #-----------------------------------------------------------------------------
 
 set(MITK_C_FLAGS "${COVERAGE_C_FLAGS} ${ADDITIONAL_C_FLAGS}")
 set(MITK_CXX_FLAGS "${VISIBILITY_CXX_FLAGS} ${COVERAGE_CXX_FLAGS} ${ADDITIONAL_CXX_FLAGS}")
 
 if(CMAKE_COMPILER_IS_GNUCXX)
   set(cflags "-Wall -Wextra -Wpointer-arith -Winvalid-pch -Wcast-align -Wwrite-strings -D_FORTIFY_SOURCE=2")
 
   mitkFunctionCheckCompilerFlags("-fdiagnostics-show-option" cflags)
   mitkFunctionCheckCompilerFlags("-Wl,--no-undefined" cflags)
 
   mitkFunctionGetGccVersion(${CMAKE_CXX_COMPILER} GCC_VERSION)
   # With older version of gcc supporting the flag -fstack-protector-all, an extra dependency to libssp.so
   # is introduced. If gcc is smaller than 4.4.0 and the build type is Release let's not include the flag.
   # Doing so should allow to build package made for distribution using older linux distro.
   if(${GCC_VERSION} VERSION_GREATER "4.4.0" OR (CMAKE_BUILD_TYPE STREQUAL "Debug" AND ${GCC_VERSION} VERSION_LESS "4.4.0"))
     mitkFunctionCheckCompilerFlags("-fstack-protector-all" cflags)
   endif()
   if(MINGW)
     # suppress warnings about auto imported symbols
     set(MITK_CXX_FLAGS "-Wl,--enable-auto-import ${MITK_CXX_FLAGS}")
     # we need to define a Windows version
     set(MITK_CXX_FLAGS "-D_WIN32_WINNT=0x0500 ${MITK_CXX_FLAGS}")
   endif()
 
   set(MITK_C_FLAGS "${cflags} ${MITK_C_FLAGS}")
   #set(MITK_CXX_FLAGS "${cflags} -Woverloaded-virtual -Wold-style-cast -Wstrict-null-sentinel -Wsign-promo ${MITK_CXX_FLAGS}")
   set(MITK_CXX_FLAGS "${cflags} -Woverloaded-virtual -Wstrict-null-sentinel ${MITK_CXX_FLAGS}")
 endif()
 
 #-----------------------------------------------------------------------------
 # MITK Modules
 #-----------------------------------------------------------------------------
 
 set(MITK_MODULES_CONF_DIR ${MITK_BINARY_DIR}/modulesConf CACHE INTERNAL "Modules Conf")
 set(MITK_MODULES_PACKAGE_DEPENDS_DIR ${MITK_SOURCE_DIR}/CMake/PackageDepends)
 set(MODULES_PACKAGE_DEPENDS_DIRS ${MITK_MODULES_PACKAGE_DEPENDS_DIR})
 
 #-----------------------------------------------------------------------------
 # Testing
 #-----------------------------------------------------------------------------
 
 if(BUILD_TESTING)
   enable_testing()
   include(CTest)
   mark_as_advanced(TCL_TCLSH DART_ROOT)
 
   option(MITK_ENABLE_GUI_TESTING OFF "Enable the MITK GUI tests")
 
   # Setup file for setting custom ctest vars
   configure_file(
     CMake/CTestCustom.cmake.in
     ${MITK_BINARY_DIR}/CTestCustom.cmake
     @ONLY
     )
 
   # Configuration for the CMake-generated test driver
   set(CMAKE_TESTDRIVER_EXTRA_INCLUDES "#include <stdexcept>")
   set(CMAKE_TESTDRIVER_BEFORE_TESTMAIN "
     try
       {")
   set(CMAKE_TESTDRIVER_AFTER_TESTMAIN "    }
       catch( std::exception & excp )
         {
         fprintf(stderr,\"%s\\n\",excp.what());
         return EXIT_FAILURE;
         }
       catch( ... )
         {
         printf(\"Exception caught in the test driver\\n\");
         return EXIT_FAILURE;
         }
       ")
 
   set(MITK_TEST_OUTPUT_DIR "${MITK_BINARY_DIR}/test_output")
   if(NOT EXISTS ${MITK_TEST_OUTPUT_DIR})
     file(MAKE_DIRECTORY ${MITK_TEST_OUTPUT_DIR})
   endif()
 endif()
 
 configure_file(mitkTestingConfig.h.in ${MITK_BINARY_DIR}/mitkTestingConfig.h)
 
 #-----------------------------------------------------------------------------
 # MITK_SUPERBUILD_BINARY_DIR
 #-----------------------------------------------------------------------------
 
 # If MITK_SUPERBUILD_BINARY_DIR isn't defined, it means MITK is *NOT* build using Superbuild.
 # In that specific case, MITK_SUPERBUILD_BINARY_DIR should default to MITK_BINARY_DIR
 if(NOT DEFINED MITK_SUPERBUILD_BINARY_DIR)
   set(MITK_SUPERBUILD_BINARY_DIR ${MITK_BINARY_DIR})
 endif()
 
 #-----------------------------------------------------------------------------
 # Compile Utilities and set-up MITK variables
 #-----------------------------------------------------------------------------
 
 add_subdirectory(Utilities)
 
 include(mitkSetupVariables)
 if(MITK_USE_BLUEBERRY)
   include(mitkSetupBlueBerry)
 endif()
 
 #-----------------------------------------------------------------------------
 # Set C/CXX Flags for MITK code
 #-----------------------------------------------------------------------------
 
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${MITK_CXX_FLAGS}" CACHE STRING "CMake CXX Flags" FORCE)
 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${MITK_C_FLAGS}" CACHE STRING "CMake C Flags" FORCE)
 
 if(MITK_USE_QT)
   add_definitions(-DQWT_DLL)
 endif()
 
 #-----------------------------------------------------------------------------
 # Add custom targets representing CDash subprojects
 #-----------------------------------------------------------------------------
 
 foreach(subproject ${CTEST_PROJECT_SUBPROJECTS})
   if(NOT TARGET ${subproject})
     add_custom_target(${subproject})
   endif()
 endforeach()
 
 #-----------------------------------------------------------------------------
 # Python Wrapping
 #-----------------------------------------------------------------------------
 
 set(MITK_WRAPPING_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/Wrapping)
 set(MITK_WRAPPING_BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR}/Wrapping)
 option(MITK_USE_PYTHON "Build cswig Python wrapper support (requires CableSwig)." OFF)
 if(MITK_USE_PYTHON)
   add_subdirectory(Wrapping)
 endif()
 
 #-----------------------------------------------------------------------------
 # Add subdirectories
 #-----------------------------------------------------------------------------
 
 link_directories(${MITK_LINK_DIRECTORIES})
 
 add_subdirectory(Core)
 add_subdirectory(CoreUI)
 add_subdirectory(Modules)
 add_subdirectory(Applications)
 
 #-----------------------------------------------------------------------------
 # Documentation
 #-----------------------------------------------------------------------------
 
 add_subdirectory(Documentation)
 
 #-----------------------------------------------------------------------------
 # Installation
 #-----------------------------------------------------------------------------
 
 if(MITK_INSTALL_RPATH_RELATIVE)
   set(CMAKE_INSTALL_RPATH ".")
 else()
   set(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/bin")
 endif()
 
 # on Mac OSX all BlueBerry plugins get copied into every
 # application bundle (.app directory) specified here
 if(APPLE)
   if(MITK_BUILD_org.mitk.gui.qt.extapplication)
     set(MACOSX_BUNDLE_NAMES ${MACOSX_BUNDLE_NAMES} ExtApp)
   endif()
   if(MITK_BUILD_org.mitk.gui.qt.application)
     set(MACOSX_BUNDLE_NAMES ${MACOSX_BUNDLE_NAMES} CoreApp)
   endif()
 endif(APPLE)
 
 # set MITK cpack variables
 include(mitkSetupCPack)
 
 if(MITK_BUILD_org.mitk.gui.qt.application)
   list(APPEND CPACK_CREATE_DESKTOP_LINKS "CoreApp")
 endif()
 if(MITK_BUILD_org.mitk.gui.qt.extapplication)
   list(APPEND CPACK_CREATE_DESKTOP_LINKS "ExtApp")
 endif()
 
 
 configure_file(${MITK_SOURCE_DIR}/MITKCPackOptions.cmake.in
                ${MITK_BINARY_DIR}/MITKCPackOptions.cmake @ONLY)
 set(CPACK_PROJECT_CONFIG_FILE "${MITK_BINARY_DIR}/MITKCPackOptions.cmake")
 
 # include CPack model once all variables are set
 include(CPack)
 
 # Additional installation rules
 include(mitkInstallRules)
 
 #-----------------------------------------------------------------------------
 # Last configuration steps
 #-----------------------------------------------------------------------------
 
 set(MITK_EXPORTS_FILE "${MITK_BINARY_DIR}/MitkExports.cmake")
 file(REMOVE ${MITK_EXPORTS_FILE})
 
 if(MITK_USE_BLUEBERRY)
   set(enabled_plugins
     ${BLUEBERRY_ENABLED_PLUGINS}
     ${MITK_CORE_ENABLED_PLUGINS}
     ${MITK_MODULES_ENABLED_PLUGINS}
     )
 
   # This is for installation support of external projects depending on
   # MITK plugins. The export file should not be used for linking to MITK
   # libraries without using LINK_DIRECTORIES, since the exports are incomplete
   # yet(depending libraries are not exported).
   foreach(plugin ${enabled_plugins})
     string(REPLACE "." "_" plugin_target ${plugin})
     export(TARGETS ${plugin_target}
            APPEND
            FILE ${MITK_EXPORTS_FILE})
   endforeach()
 endif()
 
 configure_file(${MITK_SOURCE_DIR}/CMake/ToolExtensionITKFactory.cpp.in
                ${MITK_BINARY_DIR}/ToolExtensionITKFactory.cpp.in COPYONLY)
 configure_file(${MITK_SOURCE_DIR}/CMake/ToolExtensionITKFactoryLoader.cpp.in
                ${MITK_BINARY_DIR}/ToolExtensionITKFactoryLoader.cpp.in COPYONLY)
 configure_file(${MITK_SOURCE_DIR}/CMake/ToolGUIExtensionITKFactory.cpp.in
                ${MITK_BINARY_DIR}/ToolGUIExtensionITKFactory.cpp.in COPYONLY)
 
 configure_file(mitkVersion.h.in ${MITK_BINARY_DIR}/mitkVersion.h)
 configure_file(mitkConfig.h.in ${MITK_BINARY_DIR}/mitkConfig.h)
 
 set(VECMATH_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/Utilities/vecmath)
 set(IPFUNC_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/Utilities/ipFunc)
 set(UTILITIES_DIR ${CMAKE_CURRENT_SOURCE_DIR}/Utilities)
 
 configure_file(mitkConfig.h.in ${MITK_BINARY_DIR}/mitkConfig.h)
 configure_file(MITKConfig.cmake.in ${MITK_BINARY_DIR}/MITKConfig.cmake @ONLY)
 
 
 
 
diff --git a/Core/Code/IO/mitkDicomSeriesReader.cpp b/Core/Code/IO/mitkDicomSeriesReader.cpp
index ace3c827a8..90577e9600 100644
--- a/Core/Code/IO/mitkDicomSeriesReader.cpp
+++ b/Core/Code/IO/mitkDicomSeriesReader.cpp
@@ -1,893 +1,889 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date$
 Version:   $Revision$
 
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
 // uncomment for learning more about the internal sorting mechanisms
 //#define MBILOG_ENABLE_DEBUG 
 
 #include <mitkDicomSeriesReader.h>
 
 #include <itkGDCMSeriesFileNames.h>
 
 #if GDCM_MAJOR_VERSION >= 2
   #include <gdcmAttribute.h>
   #include <gdcmPixmapReader.h>
   #include <gdcmStringFilter.h>
   #include <gdcmDirectory.h>
   #include <gdcmScanner.h>
 #endif
 
 namespace mitk
 {
 
 typedef itk::GDCMSeriesFileNames DcmFileNamesGeneratorType;
 
 DataNode::Pointer 
 DicomSeriesReader::LoadDicomSeries(const StringContainer &filenames, bool sort, bool check_4d, UpdateCallBackMethod callback)
 {
   DataNode::Pointer node = DataNode::New();
 
   if (DicomSeriesReader::LoadDicomSeries(filenames, *node, sort, check_4d, callback))
   {
     if( filenames.empty() )
     {
       return NULL;
     }
 
     return node;
   }
   else
   {
     return NULL;
   }
 }
 
 bool 
 DicomSeriesReader::LoadDicomSeries(const StringContainer &filenames, DataNode &node, bool sort, bool check_4d, UpdateCallBackMethod callback)
 {
   if( filenames.empty() )
   {
     MITK_WARN << "Calling LoadDicomSeries with empty filename string container. Probably invalid application logic.";
     node.SetData(NULL);
     return true; // this is not actually an error but the result is very simple
   }
 
   DcmIoType::Pointer io = DcmIoType::New();
 
   try
   {
     if (io->CanReadFile(filenames.front().c_str()))
     {
       io->SetFileName(filenames.front().c_str());
       io->ReadImageInformation();
 
       switch (io->GetComponentType())
       {
       case DcmIoType::UCHAR:
         DicomSeriesReader::LoadDicom<unsigned char>(filenames, node, sort, check_4d, callback);
         return true;
       case DcmIoType::CHAR:
         DicomSeriesReader::LoadDicom<char>(filenames, node, sort, check_4d, callback);
         return true;
       case DcmIoType::USHORT:
         DicomSeriesReader::LoadDicom<unsigned short>(filenames, node, sort, check_4d, callback);
         return true;
       case DcmIoType::SHORT:
         DicomSeriesReader::LoadDicom<short>(filenames, node, sort, check_4d, callback);
         return true;
       case DcmIoType::UINT:
         DicomSeriesReader::LoadDicom<unsigned int>(filenames, node, sort, check_4d, callback);
         return true;
       case DcmIoType::INT:
         DicomSeriesReader::LoadDicom<int>(filenames, node, sort, check_4d, callback);
         return true;
       case DcmIoType::ULONG:
         DicomSeriesReader::LoadDicom<long unsigned int>(filenames, node, sort, check_4d, callback);
         return true;
       case DcmIoType::LONG:
         DicomSeriesReader::LoadDicom<long int>(filenames, node, sort, check_4d, callback);
         return true;
       case DcmIoType::FLOAT:
         DicomSeriesReader::LoadDicom<float>(filenames, node, sort, check_4d, callback);
         return true;
       case DcmIoType::DOUBLE:
         DicomSeriesReader::LoadDicom<double>(filenames, node, sort, check_4d, callback);
         return true;
       default:
         MITK_ERROR << "Found unsupported DICOM pixel type: (enum value) " << io->GetComponentType();
       }
     }
   }
   catch(itk::MemoryAllocationError& e)
   {
     MITK_ERROR << "Out of memory. Cannot load DICOM series: " << e.what();
   }
   catch(std::exception& e)
   {
     MITK_ERROR << "Error encountered when loading DICOM series:" << e.what();
   }
   catch(...)
   {
     MITK_ERROR << "Unspecified error encountered when loading DICOM series.";
   }
 
   return false;
 }
 
 
 bool 
 DicomSeriesReader::IsDicom(const std::string &filename)
 {
   DcmIoType::Pointer io = DcmIoType::New();
 
   return io->CanReadFile(filename.c_str());
 }
 
 #if GDCM_MAJOR_VERSION >= 2
 bool 
 DicomSeriesReader::IsPhilips3DDicom(const std::string &filename)
 {
   DcmIoType::Pointer io = DcmIoType::New();
 
   if (io->CanReadFile(filename.c_str()))
   {
     //Look at header Tag 3001,0010 if it is "Philips3D"
     gdcm::Reader reader;
     reader.SetFileName(filename.c_str());
     reader.Read();
     gdcm::DataSet &data_set = reader.GetFile().GetDataSet();
     gdcm::StringFilter sf;
     sf.SetFile(reader.GetFile());
 
     if (data_set.FindDataElement(gdcm::Tag(0x3001, 0x0010)) &&
       (sf.ToString(gdcm::Tag(0x3001, 0x0010)) == "Philips3D "))
     {
       return true;
     }
   }
   return false;
 }
 
 bool 
 DicomSeriesReader::ReadPhilips3DDicom(const std::string &filename, mitk::Image::Pointer output_image)
 {
   // Now get PhilipsSpecific Tags
 
   gdcm::PixmapReader reader;
   reader.SetFileName(filename.c_str());
   reader.Read();
   gdcm::DataSet &data_set = reader.GetFile().GetDataSet();
   gdcm::StringFilter sf;
   sf.SetFile(reader.GetFile());
 
   gdcm::Attribute<0x0028,0x0011> dimTagX; // coloumns || sagittal
   gdcm::Attribute<0x3001,0x1001, gdcm::VR::UL, gdcm::VM::VM1> dimTagZ; //I have no idea what is VM1. // (Philips specific) // transversal
   gdcm::Attribute<0x0028,0x0010> dimTagY; // rows || coronal
   gdcm::Attribute<0x0028,0x0008> dimTagT; // how many frames
   gdcm::Attribute<0x0018,0x602c> spaceTagX; // Spacing in X , unit is "physicalTagx" (usually centimeter)
   gdcm::Attribute<0x0018,0x602e> spaceTagY;
   gdcm::Attribute<0x3001,0x1003, gdcm::VR::FD, gdcm::VM::VM1> spaceTagZ; // (Philips specific)
   gdcm::Attribute<0x0018,0x6024> physicalTagX; // if 3, then spacing params are centimeter
   gdcm::Attribute<0x0018,0x6026> physicalTagY;
   gdcm::Attribute<0x3001,0x1002, gdcm::VR::US, gdcm::VM::VM1> physicalTagZ; // (Philips specific)
 
   dimTagX.Set(data_set);
   dimTagY.Set(data_set);
   dimTagZ.Set(data_set);
   dimTagT.Set(data_set);
   spaceTagX.Set(data_set);
   spaceTagY.Set(data_set);
   spaceTagZ.Set(data_set);
   physicalTagX.Set(data_set);
   physicalTagY.Set(data_set);
   physicalTagZ.Set(data_set);
 
   unsigned int
     dimX = dimTagX.GetValue(),
     dimY = dimTagY.GetValue(),
     dimZ = dimTagZ.GetValue(),
     dimT = dimTagT.GetValue(),
     physicalX = physicalTagX.GetValue(),
     physicalY = physicalTagY.GetValue(),
     physicalZ = physicalTagZ.GetValue();
 
   float
     spaceX = spaceTagX.GetValue(),
     spaceY = spaceTagY.GetValue(),
     spaceZ = spaceTagZ.GetValue();
 
   if (physicalX == 3) // spacing parameter in cm, have to convert it to mm.
     spaceX = spaceX * 10;
 
   if (physicalY == 3) // spacing parameter in cm, have to convert it to mm.
     spaceY = spaceY * 10;
   
   if (physicalZ == 3) // spacing parameter in cm, have to convert it to mm.
     spaceZ = spaceZ * 10;
 
   // Ok, got all necessary Tags!
   // Now read Pixeldata (7fe0,0010) X x Y x Z x T Elements
 
   const gdcm::Pixmap &pixels = reader.GetPixmap();
   gdcm::RAWCodec codec;
 
   codec.SetPhotometricInterpretation(gdcm::PhotometricInterpretation::MONOCHROME2);
   codec.SetPixelFormat(pixels.GetPixelFormat());
   codec.SetPlanarConfiguration(0);
 
   gdcm::DataElement out;
   codec.Decode(data_set.GetDataElement(gdcm::Tag(0x7fe0, 0x0010)), out);
 
   const gdcm::ByteValue *bv = out.GetByteValue();
   const char *new_pixels = bv->GetPointer();
 
   // Create MITK Image + Geometry
   typedef itk::Image<unsigned char, 4> ImageType;   //Pixeltype might be different sometimes? Maybe read it out from header
   ImageType::RegionType myRegion;
   ImageType::SizeType mySize;
   ImageType::IndexType myIndex;
   ImageType::SpacingType mySpacing;
   ImageType::Pointer imageItk = ImageType::New();
 
   mySpacing[0] = spaceX;
   mySpacing[1] = spaceY;
   mySpacing[2] = spaceZ;
   mySpacing[3] = 1;
   myIndex[0] = 0;
   myIndex[1] = 0;
   myIndex[2] = 0;
   myIndex[3] = 0;
   mySize[0] = dimX;
   mySize[1] = dimY;
   mySize[2] = dimZ;
   mySize[3] = dimT;
   myRegion.SetSize( mySize);
   myRegion.SetIndex( myIndex );
   imageItk->SetSpacing(mySpacing);
   imageItk->SetRegions( myRegion);
   imageItk->Allocate();
   imageItk->FillBuffer(0);
 
   itk::ImageRegionIterator<ImageType>  iterator(imageItk, imageItk->GetLargestPossibleRegion());
   iterator.GoToBegin();
   unsigned long pixCount = 0;
   unsigned long planeSize = dimX*dimY;
   unsigned long planeCount = 0;
   unsigned long timeCount = 0;
   unsigned long numberOfSlices = dimZ;
 
   while (!iterator.IsAtEnd())
   {
     unsigned long adressedPixel =
       pixCount
       + (numberOfSlices-1-planeCount)*planeSize // add offset to adress the first pixel of current plane
       + timeCount*numberOfSlices*planeSize; // add time offset
 
     iterator.Set( new_pixels[ adressedPixel ] );
     pixCount++;
     ++iterator;
 
     if (pixCount == planeSize)
     {
       pixCount = 0;
       planeCount++;
     }
     if (planeCount == numberOfSlices)
     {
       planeCount = 0;
       timeCount++;
     }
     if (timeCount == dimT)
     {
       break;
     }
   }
   mitk::CastToMitkImage(imageItk, output_image);
   return true; // actually never returns false yet.. but exception possible
 }
 #endif
 
 DicomSeriesReader::TwoStringContainers
 DicomSeriesReader::AnalyzeFileForITKImageSeriesReaderSpacingAssumption(
     const StringContainer& files,
     const gdcm::Scanner::MappingType& tagValueMappings_)
 {
   // result.first = files that fit ITK's assumption
   // result.second = files that do not fit, should be run through AnalyzeFileForITKImageSeriesReaderSpacingAssumption() again
   TwoStringContainers result;
  
   // we const_cast here, because I could not use a map.at(), which would make the code much more readable
   gdcm::Scanner::MappingType& tagValueMappings = const_cast<gdcm::Scanner::MappingType&>(tagValueMappings_);
   const gdcm::Tag tagImagePositionPatient(0x0020,0x0032); // Image Position (Patient)
   const gdcm::Tag    tagImageOrientation(0x0020, 0x0037); // Image Orientation
 
   Vector3D fromFirstToSecondOrigin; fromFirstToSecondOrigin.Fill(0.0);
   bool fromFirstToSecondOriginInitialized(false);
   Point3D thisOrigin;
   Point3D lastOrigin;
   Point3D lastDifferentOrigin;
   bool lastOriginInitialized(false);
 
   MITK_DEBUG << "Analyzing files for z-spacing assumption of ITK's ImageSeriesReader ";
   unsigned int fileIndex(0);
   for (StringContainer::const_iterator fileIter = files.begin();
        fileIter != files.end();
        ++fileIter, ++fileIndex)
   {
     // Read tag value into point3D. PLEASE replace this by appropriate GDCM code if you figure out how to do that
     std::string thisOriginString = tagValueMappings[fileIter->c_str()][tagImagePositionPatient];
     
     std::istringstream originReader(thisOriginString);
     std::string coordinate;
     unsigned int dim(0);
     while( std::getline( originReader, coordinate, '\\' ) ) thisOrigin[dim++] = atof(coordinate.c_str());
 
     if (dim != 3)
     {
       MITK_ERROR << "Reader implementation made wrong assumption on tag (0020,0032). Found " << dim << "instead of 3 values.";
     }
     
     MITK_DEBUG << "  " << fileIndex << " " << *fileIter 
                        << " at " 
                        << thisOriginString << "(" << thisOrigin[0] << "," << thisOrigin[1] << "," << thisOrigin[2] << ")";
 
     if ( lastOriginInitialized && (thisOrigin == lastOrigin) )
     {
       MITK_DEBUG << "Sort away " << *fileIter << " for separate time step"; // we already have one occupying this position
       result.second.push_back( *fileIter );
     }
     else
     {
       if (!fromFirstToSecondOriginInitialized && lastOriginInitialized) // calculate vector as soon as possible when we get a new position
       {
         fromFirstToSecondOrigin = thisOrigin - lastDifferentOrigin;
         fromFirstToSecondOriginInitialized = true;
 
         // Now make sure this direction is along the normal vector of the first slice
         // If this is NOT the case, then we have a data set with a TILTED GANTRY geometry,
         // which cannot be loaded into a single mitk::Image at the moment
 
         // Again ugly code to read tag Image Orientation into two vEctors
         Vector3D right; right.Fill(0.0);
         Vector3D up; right.Fill(0.0); // might be down as well, but it is just a name at this point
         std::string thisOrientationString = tagValueMappings[fileIter->c_str()][tagImageOrientation];
         
         std::istringstream orientationReader(thisOrientationString);
         std::string coordinate;
         unsigned int dim(0);
         while( std::getline( orientationReader, coordinate, '\\' ) )
           if (dim<3) right[dim++] = atof(coordinate.c_str());
           else      up[dim++ - 3] = atof(coordinate.c_str());
 
         if (dim != 6)
         {
           MITK_ERROR << "Reader implementation made wrong assumption on tag (0020,0037). Found " << dim << "instead of 6 values.";
         }
 
         MITK_DEBUG << "Tilt check: right vector (" << right[0] << "," << right[1] << "," << right[2] << "), "
                                      "up vector (" << up[0] << "," << up[1] << "," << up[2] << ")";
 
         /* 
            Determine if line (thisOrigin + l * normal) contains lastDifferentOrigin.
 
            Done by calculating the distance of lastDifferentOrigin from line (thisOrigin + l *normal)
 
            E.g. http://mathworld.wolfram.com/Point-LineDistance3-Dimensional.html
 
            squared distance = | (pointAlongNormal - thisOrign) x (thisOrigin - lastDifferentOrigin) | ^ 2
                               /
                               |pointAlongNormal - thisOrigin| ^ 2
 
            ( x meaning the cross product )
         */
 
         Vector3D normal = itk::CrossProduct(right, up);
         Point3D pointAlongNormal = thisOrigin + normal;
         
         double numerator = itk::CrossProduct( pointAlongNormal - thisOrigin , thisOrigin - lastDifferentOrigin ).GetSquaredNorm();
         double denominator = (pointAlongNormal - thisOrigin).GetSquaredNorm();
 
         double distance = sqrt(numerator / denominator);
 
         if (distance > 0.001) // mitk::eps is too small; 1/1000 of a mm should be enough to detect tilt
         {
           MITK_WARN << "Series seems to contain a tilted geometry. Will load series as many single slices.";
           MITK_WARN << "Distance of expected slice origin from actual slice origin: " << distance;
 
           result.first.assign( files.begin(), fileIter );
           result.second.insert( result.second.end(), fileIter, files.end() );
 
           return result; // stop processing with first split
         }
       }
       else if (fromFirstToSecondOriginInitialized) // we already know the offset between slices
       {
         Point3D assumedOrigin = lastDifferentOrigin + fromFirstToSecondOrigin;
 
         Vector3D originError = assumedOrigin - thisOrigin;
         double norm = originError.GetNorm();
 
         if (norm > 3 * mitk::sqrteps)
         {
           MITK_WARN << "File " << *fileIter << " breaks the inter-slice distance pattern (diff = " 
                                << norm << ", allowed " 
                                << 3 * (mitk::sqrteps)<< ").";
           MITK_WARN << "Expected position (" << assumedOrigin[0] << ","
                                             << assumedOrigin[1] << ","
                                             << assumedOrigin[2] << "), got position ("
                                             << thisOrigin[0] << ","
                                             << thisOrigin[1] << ","
                                             << thisOrigin[2] << ")";
 
           // At this point we know we deviated from the expectation of ITK's ImageSeriesReader
           // We split the input file list at this point, i.e. all files up to this one (excluding it)
           // are returned as group 1, the remaining files (including the faulty one) are group 2
           
           result.first.assign( files.begin(), fileIter );
           result.second.insert( result.second.end(), fileIter, files.end() );
 
           return result; // stop processing with first split
         }
       }
 
       result.first.push_back(*fileIter);
     }
 
     // recored current origin for reference in later iterations
     if ( !lastOriginInitialized || thisOrigin != lastOrigin )
     {
       lastDifferentOrigin = thisOrigin;
     }
 
     lastOrigin = thisOrigin; 
     lastOriginInitialized = true;
   }
   
   return result;
 }
 
 DicomSeriesReader::UidFileNamesMap 
 DicomSeriesReader::GetSeries(const StringContainer& files, const StringContainer &restrictions)
 {
   return GetSeries(files, true, restrictions);
 }
   
 DicomSeriesReader::UidFileNamesMap 
 DicomSeriesReader::GetSeries(const StringContainer& files, bool sortTo3DPlust, const StringContainer &restrictions)
 {
   /**
     assumption about this method:
       returns a map of uid-like-key --> list(filename)
       each entry should contain filenames that have images of same
         - series instance uid (automatically done by GDCMSeriesFileNames
         - 0020,0037 image orientation (patient)
         - 0028,0030 pixel spacing (x,y)
         - 0018,0050 slice thickness
   */
 
 UidFileNamesMap map; // preliminary result, refined into the final result mapOf3DPlusTBlocks
 
 #if GDCM_MAJOR_VERSION < 2
   // old GDCM: let itk::GDCMSeriesFileNames do the sorting
 
   DcmFileNamesGeneratorType::Pointer name_generator = DcmFileNamesGeneratorType::New();
 
   name_generator->SetUseSeriesDetails(true);
   name_generator->AddSeriesRestriction("0020|0037"); // image orientation (patient)
   name_generator->AddSeriesRestriction("0028|0030"); // pixel spacing (x,y)
 
   name_generator->SetLoadSequences(false); // could speed up reading, and we don't use sequences anyway
   name_generator->SetLoadPrivateTags(false);
 
   for(StringContainer::const_iterator it = restrictions.begin(); 
       it != restrictions.end(); 
       ++it)
   {
     name_generator->AddSeriesRestriction(*it);
   }
 
   name_generator->SetDirectory(dir.c_str());
   const StringContainer& series_uids = name_generator->GetSeriesUIDs();
 
   for(StringContainer::const_iterator it = series_uids.begin(); 
       it != series_uids.end(); 
       ++it)
   {
     const std::string& uid = *it;
     map[uid] = name_generator->GetFileNames(uid);
   }
 
 #else
   // use GDCM directly, itk::GDCMSeriesFileNames does not work with GDCM 2
 
   // PART I: scan files for sorting relevant DICOM tags, 
   //         separate images that differ in any of those 
   //         attributes (they cannot possibly form a 3D block)
 
   // scan for relevant tags in dicom files
   gdcm::Scanner scanner;
   const gdcm::Tag tagSeriesInstanceUID(0x0020,0x000e); // Series Instance UID
     scanner.AddTag( tagSeriesInstanceUID );
 
   const gdcm::Tag tagImageOrientation(0x0020, 0x0037); // image orientation
     scanner.AddTag( tagImageOrientation );
 
   const gdcm::Tag tagPixelSpacing(0x0028, 0x0030); // pixel spacing
     scanner.AddTag( tagPixelSpacing );
     
   const gdcm::Tag tagSliceThickness(0x0018, 0x0050); // slice thickness
     scanner.AddTag( tagSliceThickness );
 
   const gdcm::Tag tagNumberOfRows(0x0028, 0x0010); // number rows
     scanner.AddTag( tagNumberOfRows );
 
   const gdcm::Tag tagNumberOfColumns(0x0028, 0x0011); // number cols
     scanner.AddTag( tagNumberOfColumns );
   
   // additional tags read in this scan to allow later analysis
   // THESE tag are not used for initial separating of files
   const gdcm::Tag tagImagePositionPatient(0x0020,0x0032); // Image Position (Patient)
     scanner.AddTag( tagImagePositionPatient );
 
   // TODO add further restrictions from arguments
 
   // let GDCM scan files
   if ( !scanner.Scan( files ) )
   {
     MITK_ERROR << "gdcm::Scanner failed when scanning " << files.size() << " input files.";
     return map;
   }
 
   // assign files IDs that will separate them for loading into image blocks
   for (gdcm::Scanner::ConstIterator fileIter = scanner.Begin();
        fileIter != scanner.End();
        ++fileIter)
   {
     MITK_DEBUG << "Read file " << fileIter->first << std::endl;
     if ( std::string(fileIter->first).empty() ) continue; // TODO understand why Scanner has empty string entries
 
     // we const_cast here, because I could not use a map.at() function in CreateMoreUniqueSeriesIdentifier.
     // doing the same thing with find would make the code less readable. Since we forget the Scanner results
     // anyway after this function, we can simply tolerate empty map entries introduced by bad operator[] access
     std::string moreUniqueSeriesId = CreateMoreUniqueSeriesIdentifier( const_cast<gdcm::Scanner::TagToValue&>(fileIter->second) );
     map [ moreUniqueSeriesId ].push_back( fileIter->first );
   }
   
   // PART II: analyze pre-sorted images for valid blocks (i.e. blocks of equal z-spacing), 
   //          separate into multiple blocks if necessary.
   //          
   //          Analysis performs the following steps:
   //            * sort slices spatially
   //            * imitate itk::ImageSeriesReader: use the distance between the first two images as z-spacing
   //            * check what images actually fulfill ITK's z-spacing assumption
   //            * separate all images that fail the test into new blocks, re-iterate analysis for these blocks
 
   for ( UidFileNamesMap::const_iterator groupIter = map.begin(); groupIter != map.end(); ++groupIter )
   {
     map[ groupIter->first ] = SortSeriesSlices( groupIter->second  ); // sort each slice group spatially
   }
 
   UidFileNamesMap mapOf3DPlusTBlocks; // final result of this function
   for ( UidFileNamesMap::const_iterator groupIter = map.begin(); groupIter != map.end(); ++groupIter )
   {
     UidFileNamesMap mapOf3DBlocks;      // intermediate result for only this group(!)
     StringContainer filesStillToAnalyze = groupIter->second;
     std::string groupUID = groupIter->first;
     unsigned int subgroup(0);
     MITK_DEBUG << "Analyze group " << groupUID;
 
     while (!filesStillToAnalyze.empty()) // repeat until all files are grouped somehow 
     {
       TwoStringContainers analysisResult = AnalyzeFileForITKImageSeriesReaderSpacingAssumption( filesStillToAnalyze, scanner.GetMappings() );
 
       // enhance the UID for additional groups
       std::stringstream newGroupUID;
       newGroupUID << groupUID << '.' << subgroup;
       mapOf3DBlocks[ newGroupUID.str() ] = analysisResult.first;
       MITK_INFO << "Sorted 3D group " << newGroupUID.str() << " with " << mapOf3DBlocks[ newGroupUID.str() ].size() << " files";
       
       ++subgroup;
         
       filesStillToAnalyze = analysisResult.second; // remember what needs further analysis
     }
 
     // end of grouping, now post-process groups
   
     // PART III: attempt to group blocks to 3D+t blocks if requested
     //           inspect entries of mapOf3DBlocks
     //            - if number of files is identical to previous entry, collect for 3D+t block
     //            - as soon as number of files changes from previous entry, record collected blocks as 3D+t block, start a new one, continue
 
     // decide whether or not to group 3D blocks into 3D+t blocks where possible
     if ( !sortTo3DPlust )
     {
       // copy 3D blocks to output
       // TODO avoid collisions (or prove impossibility)
       mapOf3DPlusTBlocks.insert( mapOf3DBlocks.begin(), mapOf3DBlocks.end() );
     }
     else
     {
       // sort 3D+t (as described in "PART III")
 
       unsigned int numberOfFilesInPreviousBlock(0);
       std::string previousBlockKey;
 
       for ( UidFileNamesMap::const_iterator block3DIter = mapOf3DBlocks.begin();
             block3DIter != mapOf3DBlocks.end();
             ++block3DIter )
       {
         unsigned int numberOfFilesInThisBlock = block3DIter->second.size();
         std::string thisBlockKey = block3DIter->first;
         
         if (numberOfFilesInPreviousBlock == 0)
         {
           numberOfFilesInPreviousBlock = numberOfFilesInThisBlock;
           mapOf3DPlusTBlocks[thisBlockKey].insert( mapOf3DPlusTBlocks[thisBlockKey].end(), 
                                                    block3DIter->second.begin(), 
                                                    block3DIter->second.end() );
           MITK_INFO << "3D+t group " << thisBlockKey << " started";
           previousBlockKey = thisBlockKey;
         }
         else
         {
           // check whether this and the previous block share a comon origin 
           // TODO should be safe, but a little try/catch or other error handling wouldn't hurt
           std::string thisOriginString = scanner.GetValue( mapOf3DBlocks[thisBlockKey].front().c_str(), tagImagePositionPatient );
           std::string previousOriginString = scanner.GetValue( mapOf3DBlocks[previousBlockKey].front().c_str(), tagImagePositionPatient );
           
           // also compare last origin, because this might differ if z-spacing is different
           std::string thisDestinationString = scanner.GetValue( mapOf3DBlocks[thisBlockKey].back().c_str(), tagImagePositionPatient );
           std::string previousDestinationString = scanner.GetValue( mapOf3DBlocks[previousBlockKey].back().c_str(), tagImagePositionPatient );
           
           bool identicalOrigins( (thisOriginString == previousOriginString) && (thisDestinationString == previousDestinationString) );
 
           if (identicalOrigins && (numberOfFilesInPreviousBlock == numberOfFilesInThisBlock))
           {
             // group with previous block
             mapOf3DPlusTBlocks[previousBlockKey].insert( mapOf3DPlusTBlocks[previousBlockKey].end(), 
                                                          block3DIter->second.begin(), 
                                                          block3DIter->second.end() );
             MITK_INFO << "3D+t group " << previousBlockKey << " enhanced with another timestep";
           }
           else
           {
             // start a new block
             mapOf3DPlusTBlocks[thisBlockKey].insert( mapOf3DPlusTBlocks[thisBlockKey].end(), 
                                                      block3DIter->second.begin(), 
                                                      block3DIter->second.end() );
             MITK_INFO << "3D+t group " << thisBlockKey << " started";
             previousBlockKey = thisBlockKey;
           }
         }
         
         numberOfFilesInPreviousBlock = numberOfFilesInThisBlock;
       }
     }
   }
 
 #endif
 
   for ( UidFileNamesMap::const_iterator groupIter = map.begin(); groupIter != map.end(); ++groupIter )
   {
     MITK_DEBUG << "Slice group " << groupIter->first << " with " << groupIter->second.size() << " files";
   }
 
   return mapOf3DPlusTBlocks;
 }
 
 DicomSeriesReader::UidFileNamesMap 
 DicomSeriesReader::GetSeries(const std::string &dir, const StringContainer &restrictions)
 {
   gdcm::Directory directoryLister;
   directoryLister.Load( dir.c_str(), false ); // non-recursive
   return GetSeries(directoryLister.GetFilenames(), restrictions);
 }
 
 #if GDCM_MAJOR_VERSION >= 2
 
 std::string
 DicomSeriesReader::CreateSeriesIdentifierPart( gdcm::Scanner::TagToValue& tagValueMap, const gdcm::Tag& tag )
 {
   std::string result;
   try
   {
     result = IDifyTagValue( tagValueMap[ tag ] ? tagValueMap[ tag ] : std::string("") );
   }
   catch (std::exception& e)
   {
     MITK_WARN << "Could not access tag " << tag << ": " << e.what();
   }
    
   return result;
 }
 
 std::string 
 DicomSeriesReader::CreateMoreUniqueSeriesIdentifier( gdcm::Scanner::TagToValue& tagValueMap )
 {
   const gdcm::Tag tagSeriesInstanceUID(0x0020,0x000e); // Series Instance UID
   const gdcm::Tag tagImageOrientation(0x0020, 0x0037); // image orientation
   const gdcm::Tag tagPixelSpacing(0x0028, 0x0030); // pixel spacing
   const gdcm::Tag tagSliceThickness(0x0018, 0x0050); // slice thickness
   const gdcm::Tag tagNumberOfRows(0x0028, 0x0010); // number rows
   const gdcm::Tag tagNumberOfColumns(0x0028, 0x0011); // number cols
     
   std::string constructedID;
  
   try
   {
     constructedID = tagValueMap[ tagSeriesInstanceUID ];
   }
   catch (std::exception& e)
   {
     MITK_ERROR << "CreateMoreUniqueSeriesIdentifier() could not access series instance UID. Something is seriously wrong with this image.";
     MITK_ERROR << "Error from exception: " << e.what();
   }
  
   constructedID += CreateSeriesIdentifierPart( tagValueMap, tagNumberOfRows );
   constructedID += CreateSeriesIdentifierPart( tagValueMap, tagNumberOfColumns );
   constructedID += CreateSeriesIdentifierPart( tagValueMap, tagPixelSpacing );
   constructedID += CreateSeriesIdentifierPart( tagValueMap, tagSliceThickness );
   constructedID += CreateSeriesIdentifierPart( tagValueMap, tagImageOrientation );
 
   constructedID.resize( constructedID.length() - 1 ); // cut of trailing '.'
 
   return constructedID; 
 }
 
 std::string 
 DicomSeriesReader::IDifyTagValue(const std::string& value)
 {
   std::string IDifiedValue( value );
   if (value.empty()) throw std::logic_error("IDifyTagValue() illegaly called with empty tag value");
 
   // Eliminate non-alnum characters, including whitespace...
   //   that may have been introduced by concats.
   for(std::size_t i=0; i<IDifiedValue.size(); i++)
   {
     while(i<IDifiedValue.size() 
       && !( IDifiedValue[i] == '.'
         || (IDifiedValue[i] >= 'a' && IDifiedValue[i] <= 'z')
         || (IDifiedValue[i] >= '0' && IDifiedValue[i] <= '9')
         || (IDifiedValue[i] >= 'A' && IDifiedValue[i] <= 'Z')))
     {
       IDifiedValue.erase(i, 1);
     }
   }
 
 
   IDifiedValue += ".";
   return IDifiedValue;
 }
 #endif
 
 DicomSeriesReader::StringContainer 
 DicomSeriesReader::GetSeries(const std::string &dir, const std::string &series_uid, const StringContainer &restrictions)
 {
   UidFileNamesMap allSeries = GetSeries(dir, restrictions);
   StringContainer resultingFileList;
 
   for ( UidFileNamesMap::const_iterator idIter = allSeries.begin(); 
         idIter != allSeries.end(); 
         ++idIter )
   {
     if ( idIter->first.find( series_uid ) == 0 ) // this ID starts with given series_uid
     {
       resultingFileList.insert( resultingFileList.end(), idIter->second.begin(), idIter->second.end() ); // append
     }
   }
 
   return resultingFileList;
 }
 
 DicomSeriesReader::StringContainer 
 DicomSeriesReader::SortSeriesSlices(const StringContainer &unsortedFilenames)
 {
 #if GDCM_MAJOR_VERSION >= 2
   gdcm::Sorter sorter;
 
   sorter.SetSortFunction(DicomSeriesReader::GdcmSortFunction);
   sorter.Sort(unsortedFilenames);
   return sorter.GetFilenames();
 #else
   return unsortedFilenames;
 #endif
 }
 
 #if GDCM_MAJOR_VERSION >= 2
 bool 
 DicomSeriesReader::GdcmSortFunction(const gdcm::DataSet &ds1, const gdcm::DataSet &ds2)
 {
   gdcm::Attribute<0x0020,0x0032> image_pos1; // Image Position (Patient)
   gdcm::Attribute<0x0020,0x0037> image_orientation1; // Image Orientation (Patient)
 
   image_pos1.Set(ds1);
   image_orientation1.Set(ds1);
 
   gdcm::Attribute<0x0020,0x0032> image_pos2;
   gdcm::Attribute<0x0020,0x0037> image_orientation2;
 
   image_pos2.Set(ds2);
   image_orientation2.Set(ds2);
 
   if (image_orientation1 != image_orientation2)
   {
     MITK_ERROR << "Dicom images have different orientations.";
     throw std::logic_error("Dicom images have different orientations. Call GetSeries() first to separate images.");
   }
 
   double normal[3];
 
   normal[0] = image_orientation1[1] * image_orientation1[5] - image_orientation1[2] * image_orientation1[4];
   normal[1] = image_orientation1[2] * image_orientation1[3] - image_orientation1[0] * image_orientation1[5];
   normal[2] = image_orientation1[0] * image_orientation1[4] - image_orientation1[1] * image_orientation1[3];
 
   double
       dist1 = 0.0,
       dist2 = 0.0;
 
   for (unsigned char i = 0u; i < 3u; ++i)
   {
     dist1 += normal[i] * image_pos1[i];
     dist2 += normal[i] * image_pos2[i];
   }
 
   if ( fabs(dist1 - dist2) < mitk::eps)
   {
     gdcm::Attribute<0x0008,0x0032> acq_time1; // Acquisition time (may be missing, so we check existence first)
     gdcm::Attribute<0x0008,0x0032> acq_time2;
 
     if (ds1.FindDataElement(gdcm::Tag(0x0008,0x0032)))
       acq_time1.Set(ds1);
 
     if (ds2.FindDataElement(gdcm::Tag(0x0008,0x0032)))
       acq_time2.Set(ds2);
 
     // TODO this could lead to comparison of unset times (does Attribute initialize to good defaults?)
     // exception: same position: compare by acquisition time
     return acq_time1 < acq_time2;
   }
   else
   {
     // default: compare position
     return dist1 < dist2;
   }
 }
 #endif
   
 std::string DicomSeriesReader::GetConfigurationString()
 {
   std::stringstream configuration;
   configuration << "MITK_USE_GDCMIO: ";
-#ifdef MITK_USE_GDCMIO
   configuration << "true";
-#else
-  configuration << "false";
-#endif
   configuration << "\n";
 
   configuration << "GDCM_VERSION: ";
 #ifdef GDCM_MAJOR_VERSION
   configuration << GDCM_VERSION;
 #endif
   //configuration << "\n";
 
   return configuration.str();
 }
 
 }
 
 #include <mitkDicomSeriesReader.txx>
 
diff --git a/Core/Code/IO/mitkDicomSeriesReader.h b/Core/Code/IO/mitkDicomSeriesReader.h
index ed27355117..d9575d5b03 100644
--- a/Core/Code/IO/mitkDicomSeriesReader.h
+++ b/Core/Code/IO/mitkDicomSeriesReader.h
@@ -1,441 +1,433 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date$
 Version:   $Revision$
 
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
 #ifndef mitkDicomSeriesReader_h
 #define mitkDicomSeriesReader_h
 
 #include "mitkDataNode.h"
 #include "mitkConfig.h"
 
-#ifdef MITK_USE_GDCMIO
-  #include <itkGDCMImageIO.h>
-#else
-  #include <itkDICOMImageIO2.h>
-#endif
+#include <itkGDCMImageIO.h>
 
 #include <itkImageSeriesReader.h>
 #include <itkCommand.h>
 
 #include <gdcmConfigure.h>
 
 #if GDCM_MAJOR_VERSION >= 2
   #include <gdcmDataSet.h>
   #include <gdcmRAWCodec.h>
   #include <gdcmSorter.h>
   #include <gdcmScanner.h>
   #include <gdcmPixmapReader.h>
   #include <gdcmStringFilter.h>
 #endif
 
 
 namespace mitk
 {
 
 /** 
  \brief Loading DICOM images as MITK images.
 
  - \ref DicomSeriesReader_purpose
  - \ref DicomSeriesReader_limitations
  - \ref DicomSeriesReader_usage
  - \ref DicomSeriesReader_sorting
    - \ref DicomSeriesReader_sorting1
    - \ref DicomSeriesReader_sorting2
    - \ref DicomSeriesReader_sorting3
    - \ref DicomSeriesReader_sorting4
 
  \section DicomSeriesReader_purpose Purpose
 
  DicomSeriesReader serves as a central class for loading DICOM images as mitk::Image.
  As the term "DICOM image" covers a huge variety of possible modalities and 
  implementations, and since MITK assumes that 3D images are made up of continuous blocks
  of slices without any gaps or changes in orientation, the loading mechanism must
  implement a number of decisions and compromises.
 
  <b>The main intention of this implementation is not efficiency but correcness of generated slice positions!</b>
 
  \section DicomSeriesReader_limitations Assumptions and limitations
 
  The class is working only with GDCM 2.0.14 (or possibly newer). This version is the
  default of an MITK super-build. Support for other versions or ITK's DicomIO was dropped
  because of the associated complexity of DicomSeriesReader.
 
  \b Assumptions
   - expected to work for SOP Classes CT Image Storage and MR Image Storage (NOT for the "Enhanced" variants containing multi-frame images)
   - special treatment for a certain type of Philips 3D ultrasound (recogized by tag 3001,0010 set to "Philips3D")
   - loader will always attempt to read multiple single slices as a single 3D image volume (i.e. mitk::Image)
     - slices will be grouped by basic properties such as orientation, rows, columns, spacing and grouped into as large blocks as possible
   
  \b Options
   - images that cover the same piece of space (i.e. position, orientation, and dimensions are equal)
     can be interpreted as time-steps of the same image, i.e. a series will be loaded as 3D+t
 
  \b Limitations
   - the 3D+t assumption only works if all time-steps have an equal number of slices and if all
     have the Acquisition Time attribute set to meaningful values
   - Images from tilted CT gantries CAN ONLY be loaded as a series of single-slice images, since
     mitk::Image or the accompanying mapper are not (yet?) capable of representing such geometries
   - Secondary Capture images are expected to have the (0018,2010) tag describing the pixel spacing.
     If only the (0028,0030) tag is set, the spacing will be misinterpreted as (1,1)
 
  \section DicomSeriesReader_usage Usage
 
  The starting point for an application is a set of DICOM files that should be loaded.
  For convenience, DicomSeriesReader can also parse a whole directory for DICOM files,
  but an application should better know exactly what to load.
 
  Loading is then done in two steps:
 
   1. <b>Group the files into spatial blocks</b> by calling GetSeries(). 
      This method will sort all passed files into meaningful blocks that
      could fit into an mitk::Image. Sorting for 3D+t loading is optional but default.
      The \b return value of this function is a list of identifiers similar to
      DICOM UIDs, each associated to a sorted list of file names.
 
   2. <b>Load a sorted set of files</b> by calling LoadDicomSeries().
      This method expects go receive the sorting output of GetSeries().
      The method will then invoke ITK methods to actually load the
      files into memory and put them into mitk::Images. Again, loading
      as 3D+t is optional.
  
   Example:
 
 \code
 
  // only a directory is known at this point: /home/who/dicom
 
  DicomSeriesReader::UidFileNamesMap allImageBlocks = DicomSeriesReader::GetSeries("/home/who/dicom/");
 
  // file now divided into groups of identical image size, orientation, spacing, etc.
  // each of these lists should be loadable as an mitk::Image.
 
  DicomSeriesReader::StringContainer seriesToLoad = allImageBlocks[...]; // decide what to load
 
  // final step: load into DataNode (can result in 3D+t image)
  DataNode::Pointer node = DicomSeriesReader::LoadDicomSeries( oneBlockSorted );
 
  Image::Pointer image = dynamic_cast<mitk::Image*>( node->GetData() );
 \endcode
 
  \section DicomSeriesReader_sorting Logic for sorting 2D slices from DICOM images into 3D+t blocks for mitk::Image
 
  The general sorting mechanism (implemented in GetSeries) groups and sorts a set of DICOM files, each assumed to contain a single CT/MR slice.
  In the following we refer to those file groups as "blocks", since this is what they are meant to become when loaded into an mitk::Image.
  
  \subsection DicomSeriesReader_sorting1 Step 1: Avoiding pure non-sense
 
  A first pass separates slices that cannot possibly be loaded together because of restrictions of mitk::Image.
  After this steps, each block contains only slices that match in all of the following DICOM tags:
 
    - (0020,0037) Image Orientation
    - (0028,0030) Pixel Spacing
    - (0028,0030) Pixel Spacing
    - (0018,0050) Slice Thickness
    - (0028,0010) Number Of Rows
    - (0028,0011) Number Of Columns
    - (0020,000e) Series Instance UID : could be argued about, might be dropped in the future (optionally)
  
  \subsection DicomSeriesReader_sorting2 Step 2: Sort slices spatially
 
  Before slices are further analyzed, they are sorted spatially. As implemented by GdcmSortFunction(),
  slices are sorted by
    1. distance from origin (calculated using (0020,0032) Image Position Patient and (0020,0037) Image Orientation)
    2. when distance is equal, (0008,0032) Acquisition Time is used as a backup criterion (necessary for meaningful 3D+t sorting)
 
  \subsection DicomSeriesReader_sorting3 Step 3: Ensure equal z spacing
 
  Since inter-slice distance is not recorded in DICOM tags, we must ensure that blocks are made up of
  slices that have equal distances between neighboring slices. This is especially necessary because itk::ImageSeriesReader
  is later used for the actual loading, and this class expects (and does nocht verify) equal inter-slice distance.
 
  To achieve such grouping, the inter-slice distance is calculated from the first two different slice positions of a block. 
  Following slices are added to a block as long as they can be added by adding the calculated inter-slice distance to the
  last slice of the block. If an unexpected gap is detected, the block is split up.
 
  Slices that share a position in space are also separated during this step. So the result of this step is a set
  of blocks that contain only slices with equal z spacing and uniqe slices at each position.
 
  \subsection DicomSeriesReader_sorting4 Step 4 (optional): group 3D blocks as 3D+t when possible
 
  This last step depends on an option of GetSeries(). When requested, image blocks from the previous step are merged again
  whenever two blocks occupy the same portion of space (i.e. same origin, number of slices and z-spacing).
 
 */
 class MITK_CORE_EXPORT DicomSeriesReader
 {
 public:
 
   /** 
     \brief Lists of filenames.
   */
   typedef std::vector<std::string> StringContainer;
 
   /** 
     \brief For grouped lists of filenames, assigned an ID each.
   */
   typedef std::map<std::string, StringContainer> UidFileNamesMap;
 
   /** 
     \brief Interface for the progress callback.
   */
   typedef void (*UpdateCallBackMethod)(float);
 
   /**
     \brief Provide combination of preprocessor defines that was active during compilation.
 
     Since this class is a combination of several possible implementations, separated only
     by ifdef's, calling instances might want to know which flags were active at compile time.
   */
   static std::string GetConfigurationString();
 
   /**
    \brief Checks if a specific file contains DICOM data.
   */
   static 
   bool 
   IsDicom(const std::string &filename);
 
   /**
    \brief see other GetSeries().
    
    Find all series (and sub-series -- see details) in a particular directory.
   */
   static UidFileNamesMap GetSeries(const std::string &dir, 
                                    const StringContainer &restrictions = StringContainer());
 
   /**
    \brief see other GetSeries().
 
    \warning Untested, could or could not work.
 
    This differs only by having an additional restriction to a single known DICOM series.
    Internally, it uses the other GetSeries() method. 
   */
   static StringContainer GetSeries(const std::string &dir, 
                                    const std::string &series_uid,
                                    const StringContainer &restrictions = StringContainer());
 
   /**
    \brief PREFERRED version of this method - scan and sort DICOM files.
 
    Parse a list of files for images of DICOM series.
    For each series, an enumeration of the files contained in it is created.
   
    \return The resulting maps UID-like keys (based on Series Instance UID and slice properties) to sorted lists of file names.
   
    SeriesInstanceUID will be enhanced to be unique for each set of file names
    that is later loadable as a single mitk::Image. This implies that
    Image orientation, slice thickness, pixel spacing, rows, and columns
    must be the same for each file (i.e. the image slice contained in the file).
   
    If this separation logic requires that a SeriesInstanceUID must be made more specialized,
    it will follow the same logic as itk::GDCMSeriesFileNames to enhance the UID with
    more digits and dots.
    
    Optionally, more tags can be used to separate files into different logical series by setting
    the restrictions parameter.
 
    \warning Adding restrictions is not yet implemented!
    */
   static
   UidFileNamesMap 
   GetSeries(const StringContainer& files, bool sortTo3DPlust, const StringContainer &restrictions = StringContainer());
   
   /**
     \brief See other GetSeries().
 
     Use GetSeries(const StringContainer& files, bool sortTo3DPlust, const StringContainer &restrictions) instead.
   */
   static
   UidFileNamesMap 
   GetSeries(const StringContainer& files, const StringContainer &restrictions = StringContainer());
 
   /**
    Loads a DICOM series composed by the file names enumerated in the file names container.
    If a callback method is supplied, it will be called after every progress update with a progress value in [0,1].
 
    \param filenames The filenames to load.
    \param sort Whether files should be sorted spatially (true) or not (false - maybe useful if presorted)
    \param load4D Whether to load the files as 3D+t (if possible)
   */
   static DataNode::Pointer LoadDicomSeries(const StringContainer &filenames, 
                                            bool sort = true, 
                                            bool load4D = true, 
                                            UpdateCallBackMethod callback = 0);
 
   /**
     \brief See LoadDicomSeries! Just a slightly different interface.
   */
   static bool LoadDicomSeries(const StringContainer &filenames, 
                               DataNode &node, 
                               bool sort = true, 
                               bool load4D = true, 
                               UpdateCallBackMethod callback = 0);
 
 protected:
 
   /**
     \brief for internal sorting.
   */
   typedef std::pair<StringContainer, StringContainer> TwoStringContainers;
 
   /**
     \brief Ensure an equal z-spacing for a group of files.
 
     Internally used by GetSeries. Returns two lists: the first one contins slices of equal inter-slice spacing.
     The second list contains remaining files, which need to be run through AnalyzeFileForITKImageSeriesReaderSpacingAssumption again.
     
     Relevant code that is matched here is in
     itkImageSeriesReader.txx (ImageSeriesReader<TOutputImage>::GenerateOutputInformation(void)), lines 176 to 245 (as of ITK 3.20)
   */
   static
   TwoStringContainers
   AnalyzeFileForITKImageSeriesReaderSpacingAssumption(const StringContainer& files, const gdcm::Scanner::MappingType& tagValueMappings);
 
   /**
     \brief Sort a set of file names in an order that is meaningful for loading them into an mitk::Image.
    
     \warning This method assumes that input files are similar in basic properties such as 
              slice thicknes, image orientation, pixel spacing, rows, columns. 
              It should always be ok to put the result of a call to GetSeries(..) into this method.
    
     Sorting order is determined by
    
      1. image position along its normal (distance from world origin)
      2. acquisition time
    
     If P<n> denotes a position and T<n> denotes a time step, this method will order slices from three timesteps like this:
 \verbatim
   P1T1 P1T2 P1T3 P2T1 P2T2 P2T3 P3T1 P3T2 P3T3
 \endverbatim
    
    */
   static StringContainer SortSeriesSlices(const StringContainer &unsortedFilenames);
 
 
 #if GDCM_MAJOR_VERSION >= 2
 public:
   /**
    \brief Checks if a specific file is a Philips3D ultrasound DICOM file.
   */
   static bool IsPhilips3DDicom(const std::string &filename);
 protected:
 
   /**
    \brief Read a Philips3D ultrasound DICOM file and put into an mitk::Image.
   */
   static bool ReadPhilips3DDicom(const std::string &filename, mitk::Image::Pointer output_image);
      
   /**
     \brief Construct a UID that takes into account sorting criteria from GetSeries().
   */
   static std::string CreateMoreUniqueSeriesIdentifier( gdcm::Scanner::TagToValue& tagValueMap );
   
   /**
     \brief Helper for CreateMoreUniqueSeriesIdentifier
   */
   static std::string CreateSeriesIdentifierPart( gdcm::Scanner::TagToValue& tagValueMap, const gdcm::Tag& tag );
   
   /**
     \brief Helper for CreateMoreUniqueSeriesIdentifier
   */
   static std::string IDifyTagValue(const std::string& value);
 #endif
 
-#ifdef MITK_USE_GDCMIO
   typedef itk::GDCMImageIO DcmIoType;
-#else
-  typedef itk::DICOMImageIO2 DcmIoType;
-#endif
 
   /**
     \brief Progress callback for DicomSeriesReader.
   */
   class CallbackCommand : public itk::Command
   {
   public:
     CallbackCommand(UpdateCallBackMethod callback)
       : m_Callback(callback)
     {
     }
 
     void Execute(const itk::Object *caller, const itk::EventObject&)
     {
       (*this->m_Callback)(static_cast<const itk::ProcessObject*>(caller)->GetProgress());
     }
 
     void Execute(itk::Object *caller, const itk::EventObject&)
     {
       (*this->m_Callback)(static_cast<itk::ProcessObject*>(caller)->GetProgress());
     }
 
   protected:
 
     UpdateCallBackMethod m_Callback;
   };
 
   /**
    \brief Performs actual loading of a series and creates an image having the specified pixel type.
   */
   template <typename PixelType>
   static 
   void 
   LoadDicom(const StringContainer &filenames, DataNode &node, bool sort, bool check_4d, UpdateCallBackMethod callback);
 
   /**
     \brief Feed files into itk::ImageSeriesReader and retrieve a 3D MITK image.
 
     \param command can be used for progress reporting
   */
   template <typename PixelType>
   static 
   Image::Pointer 
   LoadDICOMByITK( const StringContainer&, CallbackCommand* command = NULL);
 
 #if GDCM_MAJOR_VERSION >= 2
   /**
     \brief Sort files into time step blocks of a 3D+t image.
 
     Called by LoadDicom. Expects to be fed a single list of filenames that have been sorted by
     GetSeries previously (one map entry). This method will check how many timestep can be filled
     with given files.
 
     Assumption is that the number of time steps is determined by how often the first position in
     space repeats. I.e. if the first three files in the input parameter all describe the same
     location in space, we'll construct three lists of files. and sort the remaining files into them.
 
     \todo We can probably remove this method if we somehow transfer 3D+t information from GetSeries to LoadDicomSeries.
   */
   static 
   std::list<StringContainer> 
   SortIntoBlocksFor3DplusT( const StringContainer& presortedFilenames, bool sort, bool& canLoadAs4D );
 
   /*
    \brief Defines spatial sorting for sorting by GDCM 2.
 
    Sorts by image position along image normal (distance from world origin).
    In cases of conflict, acquisition time is used as a secondary sort criterium.
   */
   static 
   bool 
   GdcmSortFunction(const gdcm::DataSet &ds1, const gdcm::DataSet &ds2);
 #endif
 };
 
 }
 
 
 #endif /* MITKDICOMSERIESREADER_H_ */
diff --git a/Core/Code/Testing/DICOMTesting/CMakeLists.txt b/Core/Code/Testing/DICOMTesting/CMakeLists.txt
index 2ba6f34a77..5cf1837afb 100644
--- a/Core/Code/Testing/DICOMTesting/CMakeLists.txt
+++ b/Core/Code/Testing/DICOMTesting/CMakeLists.txt
@@ -1,35 +1,33 @@
 if (BUILD_TESTING)
-if (MITK_USE_GDCMIO)
 if (GDCM_DIR)
 
 # clear variables from prior files.cmake
 set(MODULE_TESTS)
 set(MODULE_IMAGE_TESTS)
 set(MODULE_TESTIMAGES)
 set(MODULE_CUSTOM_TESTS)
 set(H_FILES)
 set(CPP_FILES)
 
 # now create a new module only for testing purposes
 MITK_CREATE_MODULE( mitkDICOMTesting
   DEPENDS Mitk # mitkCore.so
 )
 
 
 # add helpful applications
 MITK_USE_MODULE( mitkDICOMTesting )
 include_directories(${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR} ${ALL_INCLUDE_DIRECTORIES})
 
 # dumps out image information
 add_executable(DumpDICOMMitkImage DumpDICOMMitkImage.cpp)
 target_link_libraries(DumpDICOMMitkImage ${ALL_LIBRARIES})
 
 # compares dumped out image information against reference dump
 add_executable(VerifyDICOMMitkImageDump VerifyDICOMMitkImageDump.cpp)
 target_link_libraries(VerifyDICOMMitkImageDump ${ALL_LIBRARIES})
 
 add_subdirectory(Testing)
 
 endif()
 endif()
-endif()
diff --git a/MITKConfig.cmake.in b/MITKConfig.cmake.in
index a23b7ed48b..393710903d 100644
--- a/MITKConfig.cmake.in
+++ b/MITKConfig.cmake.in
@@ -1,120 +1,119 @@
 
 # Update the CMake module path
 SET(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "@MITK_SOURCE_DIR@/CMake")
 
 # Include MITK macros
 include(MacroParseArguments)
 include(mitkFunctionOrganizeSources)
 include(mitkMacroCreateModuleConf)
 include(mitkMacroCreateModule)
 include(mitkMacroCheckModule)
 include(mitkMacroCreateModuleTests)
 include(mitkFunctionAddCustomModuleTest)
 include(mitkMacroUseModule)
 include(mitkMacroMultiplexPicType)
 include(mitkMacroInstall)
 include(mitkMacroInstallHelperApp)
 include(mitkMacroInstallTargets)
 include(mitkMacroGenerateToolsLibrary)
 
 # The MITK version number
 SET(MITK_VERSION_MAJOR "@MITK_VERSION_MAJOR@")
 SET(MITK_VERSION_MINOR "@MITK_VERSION_MINOR@")
 SET(MITK_VERSION_PATCH "@MITK_VERSION_PATCH@")
 
 # MITK specific variables
 SET(MITK_SOURCE_DIR "@MITK_SOURCE_DIR@")
 SET(UTILITIES_DIR "@UTILITIES_DIR@")
 SET(REGISTER_QFUNCTIONALITY_CPP_IN "@REGISTER_QFUNCTIONALITY_CPP_IN@")
 SET(MITK_MODULES_CONF_DIR "@MITK_MODULES_CONF_DIR@")
 SET(MITK_MODULES_PACKAGE_DEPENDS_DIR "@MITK_MODULES_PACKAGE_DEPENDS_DIR@")
 SET(MODULES_PACKAGE_DEPENDS_DIRS "@MODULES_PACKAGE_DEPENDS_DIRS@")
 SET(MITK_EXPORTS_FILE "@MITK_EXPORTS_FILE@")
 SET(MITK_DOXYGEN_TAGFILE_NAME "@MITK_DOXYGEN_TAGFILE_NAME@")
 
 # Include directory variables
 SET(MITK_INCLUDE_DIRS "@MITK_INCLUDE_DIRS@")
 SET(QMITK_INCLUDE_DIRS "@QMITK_INCLUDE_DIRS@")
 SET(ANN_INCLUDE_DIR "@ANN_INCLUDE_DIR@")
 SET(IPSEGMENTATION_INCLUDE_DIR "@IPSEGMENTATION_INCLUDE_DIR@")
 SET(VECMATH_INCLUDE_DIR "@VECMATH_INCLUDE_DIR@")
 SET(IPFUNC_INCLUDE_DIR "@IPFUNC_INCLUDE_DIR@")
 SET(MITK_IGT_INCLUDE_DIRS "@MITK_IGT_INCLUDE_DIRS@")
 
 # Library variables
 SET(MITK_LIBRARIES "@MITK_LIBRARIES@")
 SET(QMITK_LIBRARIES "@QMITK_LIBRARIES@")
 
 # Link directory variables
 SET(MITK_LINK_DIRECTORIES "@MITK_LINK_DIRECTORIES@")
 SET(QMITK_LINK_DIRECTORIES "@QMITK_LINK_DIRECTORIES@")
 SET(MITK_LIBRARY_DIRS "@CMAKE_LIBRARY_OUTPUT_DIRECTORY@")
 SET(MITK_VTK_LIBRARY_DIRS "@VTK_LIBRARY_DIRS@")
 SET(MITK_ITK_LIBRARY_DIRS "@ITK_LIBRARY_DIRS@")
 
 # External projects
 SET(ITK_DIR "@ITK_DIR@")
 SET(VTK_DIR "@VTK_DIR@")
 SET(DCMTK_DIR "@DCMTK_DIR@")
 SET(GDCM_DIR "@GDCM_DIR@")
 SET(BOOST_ROOT "@BOOST_ROOT@")
 SET(OpenCV_DIR "@OpenCV_DIR@")
 SET(MITK_QMAKE_EXECUTABLE "@QT_QMAKE_EXECUTABLE@")
 SET(MITK_INSTALL_RPATH_RELATIVE @MITK_INSTALL_RPATH_RELATIVE@)
 SET(MITK_DATA_DIR "@MITK_DATA_DIR@")
 
 # MITK use variables
 SET(MITK_USE_QT @MITK_USE_QT@)
 SET(MITK_USE_BLUEBERRY @MITK_USE_BLUEBERRY@)
 SET(MITK_USE_Boost @MITK_USE_Boost@)
 SET(MITK_USE_CTK @MITK_USE_CTK@)
-SET(MITK_USE_GDCMIO @MITK_USE_GDCMIO@)
 SET(MITK_USE_DCMTK @MITK_USE_DCMTK@)
 SET(MITK_USE_OpenCV @MITK_USE_OpenCV@)
 
 # There is no PocoConfig.cmake, so we set Poco specific CMake variables
 # here. This way the call to FIND_PACKAGE(Poco) in BlueBerryConfig.cmake
 # finds the Poco distribution supplied by MITK
 SET(Poco_INCLUDE_DIR "@MITK_SOURCE_DIR@/Utilities/Poco")
 SET(Poco_LIBRARY_DIR "@MITK_BINARY_DIR@/bin")
 
 
 IF(MITK_USE_EXT)
   #INCLUDE(${MITK_DIR}/mitkExtConfig.cmake)
   #INCLUDE(${MITK_DIR}/QmitkExtConfig.cmake)
 ENDIF()
 
 IF(MITK_USE_IGT)
   #INCLUDE(${MITK_DIR}/mitkIGTConfig.cmake)
 ENDIF()
 
 # BlueBerry support
 IF(MITK_USE_BLUEBERRY)
 
   SET(BlueBerry_DIR "@MITK_BINARY_DIR@/BlueBerry")
 
   INCLUDE(mitkMacroCreatePlugin)
 
   IF(NOT MITK_SKIP_BUNDLELIST)
     INCLUDE("@MITK_BINARY_DIR@/Bundles/MITKCoreBundleList.cmake")
     IF(MITK_USE_EXT)
       INCLUDE("@MITK_BINARY_DIR@/Bundles/MITKModulesBundleList.cmake")
     ENDIF()
   ENDIF(NOT MITK_SKIP_BUNDLELIST)
   
   FIND_PACKAGE(BlueBerry)
 
   IF(NOT BlueBerry_FOUND)
     MESSAGE(SEND_ERROR "MITK does not seem to be configured with BlueBerry support. Set MITK_USE_BLUEBERRY to ON in your MITK build configuration.")
   ENDIF(NOT BlueBerry_FOUND)
   
   SET(BLUEBERRY_OSGI_LINK_DIR "@BLUEBERRY_PLUGINS_OUTPUT_DIR@/org.blueberry.osgi/bin")
 
   SET(MITK_PLUGIN_SOURCE_DIRS "@MITK_SOURCE_DIR@/Bundles")
   
   SET(MITK_PLUGIN_OUTPUT_DIRS @MITK_CORE_PLUGIN_OUTPUT_DIRS@)
   IF(MITK_USE_EXT)
     LIST(APPEND MITK_PLUGIN_OUTPUT_DIRS @MITK_MODULES_PLUGIN_OUTPUT_DIRS@)
   ENDIF()
 
 ENDIF(MITK_USE_BLUEBERRY)
diff --git a/SuperBuild.cmake b/SuperBuild.cmake
index 9000739fe5..6d9710ec38 100644
--- a/SuperBuild.cmake
+++ b/SuperBuild.cmake
@@ -1,239 +1,238 @@
 
 #-----------------------------------------------------------------------------
 # Convenient macro allowing to download a file
 #-----------------------------------------------------------------------------
 
 MACRO(downloadFile url dest)
   FILE(DOWNLOAD ${url} ${dest} STATUS status)
   LIST(GET status 0 error_code)
   LIST(GET status 1 error_msg)
   IF(error_code)
     MESSAGE(FATAL_ERROR "error: Failed to download ${url} - ${error_msg}")
   ENDIF()
 ENDMACRO()
 
 #-----------------------------------------------------------------------------
 # MITK Prerequisites
 #-----------------------------------------------------------------------------
 
 #----------------------------- Qt ---------------------------
 if(MITK_USE_QT)
   find_package(Qt4 REQUIRED)
   set(vtk_QT_ARGS
       -DDESIRED_QT_VERSION:STRING=4
       -DVTK_USE_GUISUPPORT:BOOL=ON
       -DVTK_USE_QVTK_QTOPENGL:BOOL=ON
       -DVTK_USE_QT:BOOL=ON
       -DQT_QMAKE_EXECUTABLE:FILEPATH=${QT_QMAKE_EXECUTABLE}
      )
 endif()
 
 #-----------------------------------------------------------------------------
 # External project settings
 #-----------------------------------------------------------------------------
 
 INCLUDE(ExternalProject)
 
 SET(ep_base "${CMAKE_BINARY_DIR}/CMakeExternals")
 SET_PROPERTY(DIRECTORY PROPERTY EP_BASE ${ep_base})
 
 SET(ep_install_dir ${ep_base}/Install)
 #SET(ep_build_dir ${ep_base}/Build)
 SET(ep_source_dir ${ep_base}/Source)
 #SET(ep_parallelism_level)
 SET(ep_build_shared_libs ON)
 SET(ep_build_testing OFF)
 
 # Compute -G arg for configuring external projects with the same CMake generator:
 IF(CMAKE_EXTRA_GENERATOR)
   SET(gen "${CMAKE_EXTRA_GENERATOR} - ${CMAKE_GENERATOR}")
 ELSE()
   SET(gen "${CMAKE_GENERATOR}")
 ENDIF()
 
 # Use this value where semi-colons are needed in ep_add args:
 set(sep "^^")
 
 ##
 
 IF(MSVC90 OR MSVC10)
   SET(ep_common_C_FLAGS "${CMAKE_C_FLAGS} /bigobj /MP")
   SET(ep_common_CXX_FLAGS "${CMAKE_CXX_FLAGS} /bigobj /MP")
 ELSE()
   SET(ep_common_C_FLAGS "${CMAKE_C_FLAGS} -DLINUX_EXTRA")
   SET(ep_common_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DLINUX_EXTRA")
 ENDIF()
 
 SET(ep_common_args 
   -DBUILD_TESTING:BOOL=${ep_build_testing}
   -DCMAKE_INSTALL_PREFIX:PATH=${ep_install_dir}
   -DBUILD_SHARED_LIBS:BOOL=ON
   -DCMAKE_BUILD_TYPE:STRING=${CMAKE_BUILD_TYPE}
   -DCMAKE_C_COMPILER:FILEPATH=${CMAKE_C_COMPILER}
   -DCMAKE_CXX_COMPILER:FILEPATH=${CMAKE_CXX_COMPILER}
   -DCMAKE_C_FLAGS:STRING=${ep_common_C_FLAGS}
   -DCMAKE_CXX_FLAGS:STRING=${ep_common_CXX_FLAGS}
   #debug flags
   -DCMAKE_CXX_FLAGS_DEBUG:STRING=${CMAKE_CXX_FLAGS_DEBUG}
   -DCMAKE_C_FLAGS_DEBUG:STRING=${CMAKE_C_FLAGS_DEBUG}
   #release flags
   -DCMAKE_CXX_FLAGS_RELEASE:STRING=${CMAKE_CXX_FLAGS_RELEASE}
   -DCMAKE_C_FLAGS_RELEASE:STRING=${CMAKE_C_FLAGS_RELEASE}
   #relwithdebinfo
   -DCMAKE_CXX_FLAGS_RELWITHDEBINFO:STRING=${CMAKE_CXX_FLAGS_RELWITHDEBINFO}
   -DCMAKE_C_FLAGS_RELWITHDEBINFO:STRING=${CMAKE_C_FLAGS_RELWITHDEBINFO}
 )
 
 #-----------------------------------------------------------------------------
 # ExternalProjects 
 #-----------------------------------------------------------------------------
 
 SET(external_projects
   VTK
   GDCM
   ITK
   Boost
   DCMTK
   CTK
   OpenCV
   MITKData
   )
   
 # Include external projects
 FOREACH(p ${external_projects})
   INCLUDE(CMakeExternals/${p}.cmake)
 ENDFOREACH()
 
 #-----------------------------------------------------------------------------
 # Set superbuild boolean args
 #-----------------------------------------------------------------------------
 
 SET(mitk_cmake_boolean_args
   BUILD_SHARED_LIBS
   WITH_COVERAGE
   BUILD_TESTING
   
   MITK_USE_QT
   MITK_INSTALL_RPATH_RELATIVE
   MITK_BUILD_ALL_PLUGINS
   MITK_BUILD_TUTORIAL
   MITK_USE_Boost
-  MITK_USE_GDCMIO
   MITK_USE_BLUEBERRY
   MITK_USE_CTK
   MITK_USE_DCMTK
   MITK_USE_OpenCV
   )
   
 #-----------------------------------------------------------------------------
 # Generate cmake variable names for MITK bundles
 #-----------------------------------------------------------------------------
 
 INCLUDE(mitkSuperBuildPlugins)
 FOREACH(plugin ${MITK_SUPERBUILD_PLUGINS})
   LIST(APPEND mitk_cmake_boolean_args MITK_BUILD_${plugin})
   OPTION(MITK_BUILD_${plugin} "Build the MITK ${plugin} plugin" OFF)
 ENDFOREACH()
 
 #-----------------------------------------------------------------------------
 # Create the final variable containing superbuild boolean args
 #-----------------------------------------------------------------------------
 
 SET(mitk_superbuild_boolean_args)
 FOREACH(mitk_cmake_arg ${mitk_cmake_boolean_args})
   LIST(APPEND mitk_superbuild_boolean_args -D${mitk_cmake_arg}:BOOL=${${mitk_cmake_arg}})
 ENDFOREACH()
 
 IF(MITK_BUILD_ALL_PLUGINS)
   LIST(APPEND mitk_superbuild_boolean_args -DBLUEBERRY_BUILD_ALL_PLUGINS:BOOL=ON)
 ENDIF()
 
 #-----------------------------------------------------------------------------
 # MITK Utilities
 #-----------------------------------------------------------------------------
 
 set(proj MITK-Utilities)
 ExternalProject_Add(${proj}
   DOWNLOAD_COMMAND ""
   CONFIGURE_COMMAND ""
   BUILD_COMMAND ""
   INSTALL_COMMAND ""
   DEPENDS
     # Mandatory dependencies
     ${VTK_DEPENDS}
     ${ITK_DEPENDS}
     # Optionnal dependencies
     ${Boost_DEPENDS}
     ${CTK_DEPENDS}
     ${DCMTK_DEPENDS}
     ${OpenCV_DEPENDS}
     ${MITK-Data_DEPENDS}
 )
 
 #-----------------------------------------------------------------------------
 # MITK Configure
 #-----------------------------------------------------------------------------
 
 IF(MITK_INITIAL_CACHE_FILE)
   SET(mitk_initial_cache_arg -C "${MITK_INITIAL_CACHE_FILE}")
 ENDIF()
 
 SET(proj MITK-Configure)
 
 ExternalProject_Add(${proj}
   DOWNLOAD_COMMAND ""
   CMAKE_GENERATOR ${gen}
   CMAKE_ARGS
     ${ep_common_args}
     ${mitk_superbuild_boolean_args}
     -DMITK_USE_SUPERBUILD:BOOL=OFF
     -DCTEST_USE_LAUNCHERS:BOOL=${CTEST_USE_LAUNCHERS}
     -DMITK_SUPERBUILD_BINARY_DIR:PATH=${MITK_BINARY_DIR}
     -DQT_QMAKE_EXECUTABLE:FILEPATH=${QT_QMAKE_EXECUTABLE}
     -DMITK_KWSTYLE_EXECUTABLE:FILEPATH=${MITK_KWSTYLE_EXECUTABLE}
     -DCTK_DIR:PATH=${CTK_DIR} 
     -DDCMTK_DIR:PATH=${DCMTK_DIR}
     -DVTK_DIR:PATH=${VTK_DIR}     # FindVTK expects VTK_DIR
     -DITK_DIR:PATH=${ITK_DIR}     # FindITK expects ITK_DIR
     -DOpenCV_DIR:PATH=${OpenCV_DIR}
     -DGDCM_DIR:PATH=${GDCM_DIR}
     -DBOOST_ROOT:PATH=${BOOST_ROOT}
     -DMITK_DATA_DIR:PATH=${MITK_DATA_DIR}
     ${mitk_initial_cache_arg}
 
   SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}
   BINARY_DIR ${CMAKE_BINARY_DIR}/MITK-build
   BUILD_COMMAND ""
   INSTALL_COMMAND ""
   DEPENDS
     MITK-Utilities
   )
 
 
 #-----------------------------------------------------------------------------
 # MITK
 #-----------------------------------------------------------------------------
 
 #MESSAGE(STATUS SUPERBUILD_EXCLUDE_MITKBUILD_TARGET:${SUPERBUILD_EXCLUDE_MITKBUILD_TARGET})
 IF(NOT DEFINED SUPERBUILD_EXCLUDE_MITKBUILD_TARGET OR NOT SUPERBUILD_EXCLUDE_MITKBUILD_TARGET)
   SET(proj MITK-build)
   ExternalProject_Add(${proj}
     DOWNLOAD_COMMAND ""
     CMAKE_GENERATOR ${gen}
     SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}
     BINARY_DIR MITK-build
     INSTALL_COMMAND ""
     DEPENDS
       "MITK-Configure"
     )
 ENDIF()
 
 #-----------------------------------------------------------------------------
 # Custom target allowing to drive the build of MITK project itself
 #-----------------------------------------------------------------------------
 
 ADD_CUSTOM_TARGET(MITK
   COMMAND ${CMAKE_COMMAND} --build ${CMAKE_CURRENT_BINARY_DIR}/MITK-build
   WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/MITK-build
 )
 
diff --git a/mitkConfig.h.in b/mitkConfig.h.in
index 5b4f0c6393..8ca3344777 100644
--- a/mitkConfig.h.in
+++ b/mitkConfig.h.in
@@ -1,21 +1,20 @@
 /*
   mitkConfig.h
   this file is generated. Do not change!
 */
 #define MITK_ROOT "${PROJECT_SOURCE_DIR}/"
 #cmakedefine MITK_BUILD_SHARED_CORE
 #cmakedefine USE_ITKZLIB
 #cmakedefine MITK_CHILI_PLUGIN
 #cmakedefine MITK_USE_TD_MOUSE
-#cmakedefine MITK_USE_GDCMIO
 
 #define MITK_CHILI_PLUGIN_SDK_IPPIC_H "@MITK_CHILI_PLUGIN_SDK_IPPIC_H@"
 #define MITK_CHILI_PLUGIN_SDK_IPTYPES_H "@MITK_CHILI_PLUGIN_SDK_IPTYPES_H@"
 #define MITK_DOXYGEN_OUTPUT_DIR "@MITK_DOXYGEN_OUTPUT_DIR@"
 #define MITK_HELPPAGES_OUTPUT_DIR "@MITK_HELPPAGES_OUTPUT_DIR@"
 
 #define MITK_VERSION_MAJOR @MITK_VERSION_MAJOR@
 #define MITK_VERSION_MINOR @MITK_VERSION_MINOR@
 #define MITK_VERSION_PATCH @MITK_VERSION_PATCH@
 #define MITK_VERSION_STRING "@MITK_VERSION_STRING@"