diff --git a/CMake/mitkFunctionAddExternalProject.cmake b/CMake/mitkFunctionAddExternalProject.cmake
index 6325b72bff..d0a3a5c264 100644
--- a/CMake/mitkFunctionAddExternalProject.cmake
+++ b/CMake/mitkFunctionAddExternalProject.cmake
@@ -1,105 +1,107 @@
 #! Register an external project.
 #!
 #! Calling this function registers an external project with the MITK
 #! build system. Usage:
 #!
 #!   mitkFunctionAddExternalProject(NAME name [ON|OFF]
 #!     [PACKAGE package] [COMPONENTS comp1...]
 #!     [DEPENDS dep1...]
 #!     [DOC docstring]
 #!     [NO_CACHE] [ADVANCED] [NO_PACKAGE]
 #!   )
 #!
 #! The function creates a MITK_USE_<name> internal cache variable if the
 #! NO_CACHE option is given. If the NO_CACHE option is not set, a normal
 #! boolean cache option is created with the given DOC argument as help string.
 #! The option is marked as advanced if the ADVANCED option is set. The
 #! option's initial value matches the ON or OFF option and defaults to OFF
 #! if none is given. The DEPENDS arguments are used to force the
 #! corresponding MITK_USE_<depN> cache variables to ON if MITK_USE_<name>
 #! is ON.
 #!
 #! The PACKAGE argument names the argument for the
 #! corresponding find_package() call in MITKs top-level CMakeLists.txt
 #! and MITKConfig.cmake file. It defaults to <name>. If COMPONENTS are
 #! specified, these are passed to the find_package() call. If the
 #! NO_PACKAGE option is given, the find_package() call is suppressed.
 #!
 #! For each registered external project there must exist a file called
 #! CMakeExternals/<name>.cmake which defines the build process for
 #! the external project.
 #!
 #! \note Note that multiple calls of this function must be ordered
 #! relative to their declared dependencies. This applies to the DEPENDS
 #! arguments of this function as well as the actual target dependencies
 #! declared in the CMakeExternals/<name>.cmake file.
 #!
 function(mitkFunctionAddExternalProject)
   cmake_parse_arguments(EP "ON;OFF;NO_CACHE;ADVANCED;NO_PACKAGE" "NAME;DOC;PACKAGE" "DEPENDS;COMPONENTS" ${ARGN})
   if(NOT EP_NAME)
     message(SEND_ERROR "The NAME argument is missing.")
   endif()
   set_property(GLOBAL APPEND PROPERTY MITK_EXTERNAL_PROJECTS ${EP_NAME})
   if(NOT EP_DOC)
     set(EP_DOC "Use ${EP_NAME}")
   endif()
   if(NOT EP_PACKAGE AND NOT EP_NO_PACKAGE)
     set(EP_PACKAGE ${EP_NAME})
   endif()
 
   set(_use_var "MITK_USE_${EP_NAME}")
   set(_on 0)
-  if(EP_ON OR ${_use_var})
-    set(_on 1)
+  if(DEFINED ${_use_var})
+    set(_on ${${_use_var}})
+  else()
+    set(_on ${EP_ON})
   endif()
 
   if(_on AND EP_DEPENDS)
     # Get all transitive dependencies
     set(_depends_all)
     set(_depends_cur ${EP_DEPENDS})
     list(REMOVE_DUPLICATES _depends_cur)
     set(_depends_new ${_depends_cur})
     while(NOT "${_depends_all}" STREQUAL "${_depends_cur}")
       list(APPEND _depends_all ${_depends_new})
       set(_depends_new_tmp )
       foreach(dep ${_depends_new})
         get_property(_dep_dep GLOBAL PROPERTY MITK_${dep}_DEPENDS)
         list(APPEND _depends_new_tmp ${_dep_dep})
       endforeach()
       set(_depends_new ${_depends_new_tmp})
       if(_depends_new)
         list(REMOVE_DUPLICATES _depends_new)
         list(APPEND _depends_cur ${_depends_new})
       endif()
     endwhile()
     # Force dependencies to ON
     foreach(dep ${_depends_all})
       if(NOT MITK_USE_${dep})
         get_property(_depends_doc CACHE MITK_USE_${dep} PROPERTY HELPSTRING)
         get_property(_depends_type CACHE MITK_USE_${dep} PROPERTY TYPE)
         if(NOT TYPE STREQUAL "INTERNAL")
           # This is a cache UI variable
           message("> Forcing MITK_USE_${dep} to ON because of ${_use_var}")
           set(MITK_USE_${dep} ON CACHE BOOL "${_depends_doc}" FORCE)
         else()
           # This is an internal cache variable
           set(MITK_USE_${dep} ON CACHE INTERNAL "${_depends_doc}" FORCE)
         endif()
       endif()
     endforeach()
   endif()
 
   # Set the actual MITK_USE_<name> cache variable
   if(EP_NO_CACHE)
     set(${_use_var} ${_on} CACHE INTERNAL "${EP_DOC}" FORCE)
   else()
     env_option(${_use_var} "${EP_DOC}" ${_on})
     #set(${_use_var} ${_on} CACHE BOOL "${EP_DOC}" FORCE)
     if(EP_ADVANCED)
       mark_as_advanced(${_use_var})
     endif()
   endif()
   set_property(GLOBAL PROPERTY MITK_${EP_NAME}_PACKAGE ${EP_PACKAGE})
   set_property(GLOBAL PROPERTY MITK_${EP_NAME}_COMPONENTS "${EP_COMPONENTS}")
   set_property(GLOBAL PROPERTY MITK_${EP_NAME}_DEPENDS "${EP_DEPENDS}")
 endfunction()
diff --git a/CMake/mitkFunctionCreateModule.cmake b/CMake/mitkFunctionCreateModule.cmake
index e6468c3223..9ecf0ba7af 100644
--- a/CMake/mitkFunctionCreateModule.cmake
+++ b/CMake/mitkFunctionCreateModule.cmake
@@ -1,653 +1,653 @@
 ##################################################################
 #
 # mitk_create_module
 #
 #! Creates a module for the automatic module dependency system within MITK.
 #!
 #! Example:
 #!
 #! \code
 #! mitk_create_module(
 #!     DEPENDS PUBLIC MitkCore
 #!     PACKAGE_DEPENDS
 #!       PRIVATE Qt5|Xml+Networking
 #!       PUBLIC  ITK|Watershed
 #!     WARNINGS_AS_ERRORS
 #! \endcode
 #!
 #! The <moduleName> parameter specifies the name of the module which is used
 #! to create a logical target name. The parameter is optional in case the
 #! MITK_MODULE_NAME_DEFAULTS_TO_DIRECTORY_NAME variable evaluates to TRUE. The
 #! module name will then be derived from the directory name in which this
 #! function is called.
 #!
 #! If set, the following variables will be used to validate the module name:
 #!
 #!   MITK_MODULE_NAME_REGEX_MATCH The module name must match this regular expression.
 #!   MITK_MODULE_NAME_REGEX_NOT_MATCH The module name must not match this regular expression.
 #!
 #! If the MITK_MODULE_NAME_PREFIX variable is set, the module name will be prefixed
 #! with its contents.
 #!
 #! A modules source files are specified in a separate CMake file usually
 #! called files.cmake, located in the module root directory. The
 #! mitk_create_module() macro evaluates the following CMake variables
 #! from the files.cmake file:
 #!
 #! - CPP_FILES A list of .cpp files
 #! - H_FILES A list of .h files without a corresponding .cpp file
 #! - TXX_FILES A list of .txx files
 #! - RESOURCE_FILES A list of files (resources) which are embedded into the module
 #! - MOC_H_FILES A list of Qt header files which should be processed by the MOC
 #! - UI_FILES A list of .ui Qt UI files
 #! - QRC_FILES A list of .qrc Qt resource files
 #! - DOX_FILES A list of .dox Doxygen files
 #!
 #! List of variables available after the function is called:
 #! - MODULE_NAME
 #! - MODULE_TARGET
 #! - MODULE_IS_ENABLED
 #! - MODULE_SUBPROJECTS
 #!
 #! \sa mitk_create_executable
 #!
 #! Parameters (all optional):
 #!
 #! \param <moduleName> The module name (also used as target name)
 #! \param FILES_CMAKE File name of a CMake file setting source list variables
 #!        (defaults to files.cmake)
 #! \param VERSION Module version number, e.g. "1.2.0"
 #! \param AUTOLOAD_WITH A module target name identifying the module which will
 #!        trigger the automatic loading of this module
 #! \param DEPRECATED_SINCE Marks this modules as deprecated since <arg>
 #! \param DESCRIPTION A description for this module
 #!
 #! Multi-value Parameters (all optional):
 #!
 #! \param SUBPROJECTS List of CDash labels
 #! \param INCLUDE_DIRS Include directories for this module:
 #!        \verbatim
 #! [[PUBLIC|PRIVATE|INTERFACE] <dir1>...]...
 #! \endverbatim
 #!        The default scope for include directories is PUBLIC.
 #! \param DEPENDS List of module dependencies:
 #!        \verbatim
 #! [[PUBLIC|PRIVATE|INTERFACE] <module1>...]...
 #! \endverbatim
 #!        The default scope for module dependencies is PUBLIC.
 #! \param PACKAGE_DEPENDS List of public packages dependencies (e.g. Qt, VTK, etc.).
 #!        Package dependencies have the following syntax:
 #!        \verbatim
 #! [PUBLIC|PRIVATE|INTERFACE] PACKAGE[|COMPONENT1[+COMPONENT2]...]
 #! \endverbatim
 #!        The default scope for package dependencies is PRIVATE.
 #! \param ADDITIONAL_LIBS List of addidtional private libraries linked to this module.
 #!        The folder containing the library will be added to the global list of library search paths.
 #! \param CPP_FILES List of source files for this module. If the list is non-empty,
 #!        the module does not need to provide a files.cmake file or FILES_CMAKE argument.
 #! \param H_FILES List of public header files for this module. It is recommended to use
 #!        a files.cmake file instead.
 #!
 #! Options (optional)
 #!
 #! \param FORCE_STATIC Force building this module as a static library
 #! \param GCC_DEFAULT_VISIBILITY Do not use gcc visibility flags - all
 #!        symbols will be exported
 #! \param NO_INIT Do not create CppMicroServices initialization code
 #! \param NO_FEATURE_INFO Do not create a feature info by calling add_feature_info()
 #! \param WARNINGS_AS_ERRORS Treat compiler warnings as errors
 #
 ##################################################################
 function(mitk_create_module)
 
   set(_macro_params
       VERSION                # module version number, e.g. "1.2.0"
       EXPORT_DEFINE          # export macro name for public symbols of this module (DEPRECATED)
       AUTOLOAD_WITH          # a module target name identifying the module which will trigger the
                              # automatic loading of this module
       FILES_CMAKE            # file name of a CMake file setting source list variables
                              # (defaults to files.cmake)
       DEPRECATED_SINCE       # marks this modules as deprecated
       DESCRIPTION            # a description for this module
      )
 
   set(_macro_multiparams
       SUBPROJECTS            # list of CDash labels
       INCLUDE_DIRS           # include directories: [PUBLIC|PRIVATE|INTERFACE] <list>
       INTERNAL_INCLUDE_DIRS  # include dirs internal to this module (DEPRECATED)
       DEPENDS                # list of modules this module depends on: [PUBLIC|PRIVATE|INTERFACE] <list>
       DEPENDS_INTERNAL       # list of modules this module internally depends on (DEPRECATED)
       PACKAGE_DEPENDS        # list of "packages this module depends on (e.g. Qt, VTK, etc.): [PUBLIC|PRIVATE|INTERFACE] <package-list>
       TARGET_DEPENDS         # list of CMake targets this module should depend on
       ADDITIONAL_LIBS        # list of addidtional private libraries linked to this module.
       CPP_FILES              # list of cpp files
       H_FILES                # list of header files: [PUBLIC|PRIVATE] <list>
      )
 
   set(_macro_options
       FORCE_STATIC           # force building this module as a static library
       HEADERS_ONLY           # this module is a headers-only library
       GCC_DEFAULT_VISIBILITY # do not use gcc visibility flags - all symbols will be exported
       NO_DEFAULT_INCLUDE_DIRS # do not add default include directories like "include" or "."
       NO_INIT                # do not create CppMicroServices initialization code
       NO_FEATURE_INFO        # do not create a feature info by calling add_feature_info()
       WARNINGS_AS_ERRORS     # treat all compiler warnings as errors
       EXECUTABLE             # create an executable; do not use directly, use mitk_create_executable() instead
       C_MODULE               # compile all source files as C sources
       CXX_MODULE             # compile all source files as C++ sources
      )
 
   cmake_parse_arguments(MODULE "${_macro_options}" "${_macro_params}" "${_macro_multiparams}" ${ARGN})
 
   set(MODULE_NAME ${MODULE_UNPARSED_ARGUMENTS})
 
   if(NOT MODULE_NAME)
     if(MITK_MODULE_NAME_DEFAULTS_TO_DIRECTORY_NAME)
       get_filename_component(MODULE_NAME ${CMAKE_CURRENT_SOURCE_DIR} NAME)
     else()
       message(SEND_ERROR "The module name must not be empty")
     endif()
   endif()
 
   set(_deprecated_args INTERNAL_INCLUDE_DIRS DEPENDS_INTERNAL EXPORT_DEFINE TARGET_DEPENDS HEADERS_ONLY)
   foreach(_deprecated_arg ${_deprecated_args})
     if(MODULE_${_deprecated_arg})
       message(WARNING "The ${_deprecated_arg} argument is deprecated")
     endif()
   endforeach()
 
   set(_module_type module)
   set(_Module_type Module)
   if(MODULE_EXECUTABLE)
     set(_module_type executable)
     set(_Module_type Executable)
   endif()
 
   if(MITK_MODULE_NAME_REGEX_MATCH)
     if(NOT ${MODULE_NAME} MATCHES ${MITK_MODULE_NAME_REGEX_MATCH})
       message(SEND_ERROR "The ${_module_type} name \"${MODULE_NAME}\" does not match the regular expression \"${MITK_MODULE_NAME_REGEX_MATCH}\".")
     endif()
   endif()
   if(MITK_MODULE_NAME_REGEX_NOT_MATCH)
     if(${MODULE_NAME} MATCHES ${MITK_MODULE_NAME_REGEX_NOT_MATCH})
       message(SEND_ERROR "The ${_module_type} name \"${MODULE_NAME}\" must not match the regular expression \"${MITK_MODULE_NAME_REGEX_NOT_MATCH}\".")
     endif()
   endif()
 
   if(MITK_MODULE_NAME_PREFIX AND NOT MODULE_NAME MATCHES "^${MITK_MODULE_NAME_PREFIX}.*$")
     set(MODULE_NAME "${MITK_MODULE_NAME_PREFIX}${MODULE_NAME}")
   endif()
 
   if(NOT MODULE_FILES_CMAKE)
     set(MODULE_FILES_CMAKE files.cmake)
   endif()
   if(NOT IS_ABSOLUTE ${MODULE_FILES_CMAKE})
     set(MODULE_FILES_CMAKE ${CMAKE_CURRENT_SOURCE_DIR}/${MODULE_FILES_CMAKE})
   endif()
 
   if(MODULE_HEADERS_ONLY)
     set(MODULE_TARGET )
     if(MODULE_AUTOLOAD_WITH)
       message(SEND_ERROR "A headers only module cannot be auto-loaded")
     endif()
   else()
     set(MODULE_TARGET ${MODULE_NAME})
   endif()
 
   if(NOT MODULE_SUBPROJECTS)
     if(MITK_DEFAULT_SUBPROJECTS)
       set(MODULE_SUBPROJECTS ${MITK_DEFAULT_SUBPROJECTS})
     endif()
   endif()
 
   # check if the subprojects exist as targets
   if(MODULE_SUBPROJECTS)
     foreach(subproject ${MODULE_SUBPROJECTS})
       if(NOT TARGET ${subproject})
         message(SEND_ERROR "The subproject ${subproject} does not have a corresponding target")
       endif()
     endforeach()
   endif()
 
   # assume worst case
   set(MODULE_IS_ENABLED 0)
   # first we check if we have an explicit module build list
   if(MITK_MODULES_TO_BUILD)
     list(FIND MITK_MODULES_TO_BUILD ${MODULE_NAME} _MOD_INDEX)
     if(_MOD_INDEX EQUAL -1)
       set(MODULE_IS_EXCLUDED 1)
     endif()
   endif()
 
   if(NOT MODULE_IS_EXCLUDED)
     # first of all we check for the dependencies
     _mitk_parse_package_args(${MODULE_PACKAGE_DEPENDS})
     mitk_check_module_dependencies(MODULES ${MODULE_DEPENDS}
                                    PACKAGES ${PACKAGE_NAMES}
                                    MISSING_DEPENDENCIES_VAR _MISSING_DEP
                                    PACKAGE_DEPENDENCIES_VAR PACKAGE_NAMES)
 
     if(_MISSING_DEP)
       if(MODULE_NO_FEATURE_INFO)
         message("${_Module_type} ${MODULE_NAME} won't be built, missing dependency: ${_MISSING_DEP}")
       endif()
       set(MODULE_IS_ENABLED 0)
     else()
       set(MODULE_IS_ENABLED 1)
       # now check for every package if it is enabled. This overlaps a bit with
       # MITK_CHECK_MODULE ...
       foreach(_package ${PACKAGE_NAMES})
         if((DEFINED MITK_USE_${_package}) AND NOT (MITK_USE_${_package}))
           message("${_Module_type} ${MODULE_NAME} won't be built. Turn on MITK_USE_${_package} if you want to use it.")
           set(MODULE_IS_ENABLED 0)
           break()
         endif()
       endforeach()
 
       if(MODULE_IS_ENABLED)
 
         # clear variables defined in files.cmake
         set(RESOURCE_FILES )
         set(CPP_FILES )
         set(H_FILES )
         set(TXX_FILES )
         set(DOX_FILES )
         set(UI_FILES )
         set(MOC_H_FILES )
         set(QRC_FILES )
 
         # clear other variables
         set(Q${KITNAME}_GENERATED_CPP )
         set(Q${KITNAME}_GENERATED_MOC_CPP )
         set(Q${KITNAME}_GENERATED_QRC_CPP )
         set(Q${KITNAME}_GENERATED_UI_CPP )
 
         # check and set-up auto-loading
         if(MODULE_AUTOLOAD_WITH)
           if(NOT TARGET "${MODULE_AUTOLOAD_WITH}")
             message(SEND_ERROR "The module target \"${MODULE_AUTOLOAD_WITH}\" specified as the auto-loading module for \"${MODULE_NAME}\" does not exist")
           endif()
         endif()
         set(_module_autoload_meta_target "${CMAKE_PROJECT_NAME}-autoload")
         # create a meta-target if it does not already exist
         if(NOT TARGET ${_module_autoload_meta_target})
           add_custom_target(${_module_autoload_meta_target})
         endif()
 
         if(NOT MODULE_EXPORT_DEFINE)
           set(MODULE_EXPORT_DEFINE ${MODULE_NAME}_EXPORT)
         endif()
 
         if(MITK_GENERATE_MODULE_DOT)
           message("MODULEDOTNAME ${MODULE_NAME}")
           foreach(dep ${MODULE_DEPENDS})
             message("MODULEDOT \"${MODULE_NAME}\" -> \"${dep}\" ; ")
           endforeach(dep)
         endif(MITK_GENERATE_MODULE_DOT)
 
         # ok, now create the module itself
         if (EXISTS ${MODULE_FILES_CMAKE})
           include(${MODULE_FILES_CMAKE})
         elseif(NOT MODULE_CPP_FILES AND NOT MODULE_HEADERS_ONLY)
           message("WARNING No cmake file found AND no cpp files specified... ")
         endif()
 
         if(MODULE_CPP_FILES)
           list(APPEND CPP_FILES ${MODULE_CPP_FILES})
         endif()
 
         if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src")
           # Preprend the "src" directory to the cpp file list
           set(_cpp_files ${CPP_FILES})
           set(CPP_FILES )
           foreach(_cpp_file ${_cpp_files})
             list(APPEND CPP_FILES "src/${_cpp_file}")
           endforeach()
         endif()
 
         if(CPP_FILES)
           set(MODULE_HEADERS_ONLY 0)
           if(MODULE_C_MODULE)
             set_source_files_properties(${CPP_FILES} PROPERTIES LANGUAGE C)
           elseif(MODULE_CXX_MODULE)
             set_source_files_properties(${CPP_FILES} PROPERTIES LANGUAGE CXX)
           endif()
         else()
           set(MODULE_HEADERS_ONLY 1)
         endif()
 
         set(module_c_flags )
         set(module_c_flags_debug )
         set(module_c_flags_release )
         set(module_cxx_flags )
         set(module_cxx_flags_debug )
         set(module_cxx_flags_release )
 
         if(MODULE_GCC_DEFAULT_VISIBILITY OR NOT CMAKE_COMPILER_IS_GNUCXX)
           # We only support hidden visibility for gcc for now. Clang still has troubles with
           # correctly marking template declarations and explicit template instantiations as exported.
           # See http://comments.gmane.org/gmane.comp.compilers.clang.scm/50028
           # and http://llvm.org/bugs/show_bug.cgi?id=10113
           set(CMAKE_CXX_VISIBILITY_PRESET default)
           set(CMAKE_VISIBILITY_INLINES_HIDDEN 0)
         else()
           set(CMAKE_CXX_VISIBILITY_PRESET hidden)
           set(CMAKE_VISIBILITY_INLINES_HIDDEN 1)
         endif()
 
         if(MODULE_WARNINGS_AS_ERRORS)
           if(MSVC_VERSION)
             mitkFunctionCheckCAndCXXCompilerFlags("/WX" module_c_flags module_cxx_flags)
           else()
             mitkFunctionCheckCAndCXXCompilerFlags(-Werror module_c_flags module_cxx_flags)
 
             # The flag "c++0x-static-nonintegral-init" has been renamed in newer Clang
             # versions to "static-member-init", see
             # http://clang-developers.42468.n3.nabble.com/Wc-0x-static-nonintegral-init-gone-td3999651.html
             #
             # Also, older Clang and seemingly all gcc versions do not warn if unknown
             # "-no-*" flags are used, so CMake will happily append any -Wno-* flag to the
             # command line. This may get confusing if unrelated compiler errors happen and
             # the error output then additionally contains errors about unknown flags (which
             # is not the case if there were no compile errors).
             #
             # So instead of using -Wno-* we use -Wno-error=*, which will be properly rejected by
             # the compiler and if applicable, prints the specific warning as a real warning and
             # not as an error (although -Werror was given).
 
             mitkFunctionCheckCAndCXXCompilerFlags("-Wno-error=c++0x-static-nonintegral-init" module_c_flags module_cxx_flags)
             mitkFunctionCheckCAndCXXCompilerFlags("-Wno-error=static-member-init" module_c_flags module_cxx_flags)
             mitkFunctionCheckCAndCXXCompilerFlags("-Wno-error=unknown-warning" module_c_flags module_cxx_flags)
             mitkFunctionCheckCAndCXXCompilerFlags("-Wno-error=gnu" module_c_flags module_cxx_flags)
           endif()
         endif(MODULE_WARNINGS_AS_ERRORS)
 
         if(MODULE_FORCE_STATIC)
           set(_STATIC STATIC)
         else()
           set(_STATIC )
         endif(MODULE_FORCE_STATIC)
 
         if(NOT MODULE_HEADERS_ONLY)
           if(NOT MODULE_NO_INIT OR RESOURCE_FILES)
             find_package(CppMicroServices QUIET NO_MODULE REQUIRED)
           endif()
           if(NOT MODULE_NO_INIT)
             usFunctionGenerateModuleInit(CPP_FILES)
           endif()
 
           set(binary_res_files )
           set(source_res_files )
           if(RESOURCE_FILES)
             if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/resource")
               set(res_dir resource)
             elseif(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/Resources")
               set(res_dir Resources)
             else()
               message(SEND_ERROR "Resources specified but ${CMAKE_CURRENT_SOURCE_DIR}/resource directory not found.")
             endif()
             foreach(res_file ${RESOURCE_FILES})
               if(EXISTS ${CMAKE_CURRENT_BINARY_DIR}/${res_dir}/${res_file})
                 list(APPEND binary_res_files "${res_file}")
               else()
                 list(APPEND source_res_files "${res_file}")
               endif()
             endforeach()
 
             # Add a source level dependencies on resource files
             usFunctionGetResourceSource(TARGET ${MODULE_TARGET} OUT CPP_FILES)
           endif()
         endif()
 
         # Qt 4 case
         if(MITK_USE_Qt4)
           if(UI_FILES)
             qt4_wrap_ui(Q${KITNAME}_GENERATED_UI_CPP ${UI_FILES})
           endif()
           if(MOC_H_FILES)
             qt4_wrap_cpp(Q${KITNAME}_GENERATED_MOC_CPP ${MOC_H_FILES} OPTIONS -DBOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
           endif()
           if(QRC_FILES)
             qt4_add_resources(Q${KITNAME}_GENERATED_QRC_CPP ${QRC_FILES})
           endif()
         endif()
 
         # all the same for Qt 5
         if(MITK_USE_Qt5)
           if(UI_FILES)
             qt5_wrap_ui(Q${KITNAME}_GENERATED_UI_CPP ${UI_FILES})
           endif()
           if(MOC_H_FILES)
             qt5_wrap_cpp(Q${KITNAME}_GENERATED_MOC_CPP ${MOC_H_FILES} OPTIONS -DBOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
           endif()
           if(QRC_FILES)
             qt5_add_resources(Q${KITNAME}_GENERATED_QRC_CPP ${QRC_FILES})
           endif()
         endif()
 
         set(Q${KITNAME}_GENERATED_CPP ${Q${KITNAME}_GENERATED_CPP} ${Q${KITNAME}_GENERATED_UI_CPP} ${Q${KITNAME}_GENERATED_MOC_CPP} ${Q${KITNAME}_GENERATED_QRC_CPP})
 
         ORGANIZE_SOURCES(SOURCE ${CPP_FILES}
                          HEADER ${H_FILES}
                          TXX ${TXX_FILES}
                          DOC ${DOX_FILES}
                          UI ${UI_FILES}
                          QRC ${QRC_FILES}
                          MOC ${Q${KITNAME}_GENERATED_MOC_CPP}
                          GEN_QRC ${Q${KITNAME}_GENERATED_QRC_CPP}
                          GEN_UI ${Q${KITNAME}_GENERATED_UI_CPP})
 
         set(coverage_sources
             ${CPP_FILES} ${H_FILES} ${GLOBBED__H_FILES} ${CORRESPONDING__H_FILES} ${TXX_FILES}
             ${TOOL_CPPS} ${TOOL_GUI_CPPS})
 
         if(MODULE_SUBPROJECTS)
           set_property(SOURCE ${coverage_sources} APPEND PROPERTY LABELS ${MODULE_SUBPROJECTS} MITK)
         endif()
 
         if(NOT MODULE_HEADERS_ONLY)
 
           if(MODULE_EXECUTABLE)
             add_executable(${MODULE_TARGET}
                            ${MODULE_CPP_FILES} ${coverage_sources} ${CPP_FILES_GENERATED} ${Q${KITNAME}_GENERATED_CPP}
                            ${DOX_FILES} ${UI_FILES} ${QRC_FILES})
             set(_us_module_name main)
           else()
             add_library(${MODULE_TARGET} ${_STATIC}
                         ${coverage_sources} ${CPP_FILES_GENERATED} ${Q${KITNAME}_GENERATED_CPP}
                         ${DOX_FILES} ${UI_FILES} ${QRC_FILES})
             set(_us_module_name ${MODULE_TARGET})
           endif()
 
           # Apply properties to the module target.
           target_compile_definitions(${MODULE_TARGET} PRIVATE US_MODULE_NAME=${_us_module_name})
           if(MODULE_C_MODULE)
             if(module_c_flags)
               string(REPLACE " " ";" module_c_flags "${module_c_flags}")
               target_compile_options(${MODULE_TARGET} PRIVATE ${module_c_flags})
             endif()
             if(module_c_flags_debug)
               string(REPLACE " " ";" module_c_flags_debug "${module_c_flags_debug}")
               target_compile_options(${MODULE_TARGET} PRIVATE $<$<CONFIG:Debug>:${module_c_flags_debug}>)
             endif()
             if(module_c_flags_release)
               string(REPLACE " " ";" module_c_flags_release "${module_c_flags_release}")
               target_compile_options(${MODULE_TARGET} PRIVATE $<$<CONFIG:Release>:${module_c_flags_release}>)
             endif()
           else()
             if(module_cxx_flags)
               string(REPLACE " " ";" module_cxx_flags "${module_cxx_flags}")
               target_compile_options(${MODULE_TARGET} PRIVATE ${module_cxx_flags})
             endif()
             if(module_cxx_flags_debug)
               string(REPLACE " " ";" module_cxx_flags_debug "${module_cxx_flags_debug}")
               target_compile_options(${MODULE_TARGET} PRIVATE $<$<CONFIG:Debug>:${module_cxx_flags_debug}>)
             endif()
             if(module_cxx_flags_release)
               string(REPLACE " " ";" module_cxx_flags_release "${module_cxx_flags_release}")
               target_compile_options(${MODULE_TARGET} PRIVATE $<$<CONFIG:Release>:${module_cxx_flags_release}>)
             endif()
           endif()
 
           set_property(TARGET ${MODULE_TARGET} PROPERTY US_MODULE_NAME ${_us_module_name})
           if(MODULE_DEPRECATED_SINCE)
             set_property(TARGET ${MODULE_TARGET} PROPERTY MITK_MODULE_DEPRECATED_SINCE ${MODULE_DEPRECATED_SINCE})
           endif()
 
           if(MODULE_TARGET_DEPENDS)
             add_dependencies(${MODULE_TARGET} ${MODULE_TARGET_DEPENDS})
           endif()
 
           if(MODULE_SUBPROJECTS)
             set_property(TARGET ${MODULE_TARGET} PROPERTY LABELS ${MODULE_SUBPROJECTS} MITK)
             foreach(subproject ${MODULE_SUBPROJECTS})
               add_dependencies(${subproject} ${MODULE_TARGET})
             endforeach()
           endif()
 
           set(DEPENDS "${MODULE_DEPENDS}")
           if(NOT MODULE_NO_INIT)
             # Add a CppMicroServices dependency implicitly, since it is
             # needed for the generated "module initialization" code.
             set(DEPENDS "CppMicroServices;${DEPENDS}")
           endif()
           if(DEPENDS OR MODULE_PACKAGE_DEPENDS)
             mitk_use_modules(TARGET ${MODULE_TARGET}
                              MODULES ${DEPENDS}
                              PACKAGES ${MODULE_PACKAGE_DEPENDS}
                             )
           endif()
 
           if(MINGW)
             target_link_libraries(${MODULE_TARGET} ssp) # add stack smash protection lib
           endif()
 
           # Add additional library search directories to a global property which
           # can be evaluated by other CMake macros, e.g. our install scripts.
           if(MODULE_ADDITIONAL_LIBS)
             target_link_libraries(${MODULE_TARGET} PRIVATE ${MODULE_ADDITIONAL_LIBS})
             get_property(_mitk_additional_library_search_paths GLOBAL PROPERTY MITK_ADDITIONAL_LIBRARY_SEARCH_PATHS)
             foreach(_lib_filepath ${MODULE_ADDITIONAL_LIBS})
               get_filename_component(_search_path "${_lib_filepath}" PATH)
               if(_search_path)
                 list(APPEND _mitk_additional_library_search_paths "${_search_path}")
               endif()
             endforeach()
             if(_mitk_additional_library_search_paths)
               list(REMOVE_DUPLICATES _mitk_additional_library_search_paths)
               set_property(GLOBAL PROPERTY MITK_ADDITIONAL_LIBRARY_SEARCH_PATHS ${_mitk_additional_library_search_paths})
             endif()
           endif()
 
           # add the target name to a global property which is used in the top-level
           # CMakeLists.txt file to export the target
           set_property(GLOBAL APPEND PROPERTY MITK_MODULE_TARGETS ${MODULE_TARGET})
           if(MODULE_AUTOLOAD_WITH)
             # for auto-loaded modules, adapt the output directory
             add_dependencies(${_module_autoload_meta_target} ${MODULE_TARGET})
             if(WIN32)
               set(_module_output_prop RUNTIME_OUTPUT_DIRECTORY)
             else()
               set(_module_output_prop LIBRARY_OUTPUT_DIRECTORY)
             endif()
             set(_module_output_dir ${CMAKE_${_module_output_prop}}/${MODULE_AUTOLOAD_WITH})
             get_target_property(_module_is_imported ${MODULE_AUTOLOAD_WITH} IMPORTED)
             if(NOT _module_is_imported)
               # if the auto-loading module is not imported, get its location
               # and put the auto-load module relative to it.
               get_target_property(_module_output_dir ${MODULE_AUTOLOAD_WITH} ${_module_output_prop})
               set_target_properties(${MODULE_TARGET} PROPERTIES
                                     ${_module_output_prop} ${_module_output_dir}/${MODULE_AUTOLOAD_WITH})
             else()
               set_target_properties(${MODULE_TARGET} PROPERTIES
                                     ${_module_output_prop} ${CMAKE_${_module_output_prop}}/${MODULE_AUTOLOAD_WITH})
             endif()
             set_target_properties(${MODULE_TARGET} PROPERTIES
                                   MITK_AUTOLOAD_DIRECTORY ${MODULE_AUTOLOAD_WITH})
 
             # add the auto-load module name as a property
             set_property(TARGET ${MODULE_AUTOLOAD_WITH} APPEND PROPERTY MITK_AUTOLOAD_TARGETS ${MODULE_TARGET})
           endif()
 
           if(binary_res_files)
             usFunctionAddResources(TARGET ${MODULE_TARGET}
                                    WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/${res_dir}
                                    FILES ${binary_res_files})
           endif()
           if(source_res_files)
             usFunctionAddResources(TARGET ${MODULE_TARGET}
                                    WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/${res_dir}
                                    FILES ${source_res_files})
           endif()
           if(binary_res_files OR source_res_files)
             usFunctionEmbedResources(TARGET ${MODULE_TARGET})
           endif()
 
         endif()
 
         if(NOT MODULE_C_MODULE)
           # Add required compile features, currently works only for GNU (gcc) and Clang (not AppleClang).
           # For all other cases, MITKConfig.cmake prints an error if CMAKE_CXX_STANDARD is not set to C++11
-          if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU" OR
+          if((CMAKE_CXX_COMPILER_ID STREQUAL "GNU" AND GCC_VERSION VERSION_GREATER 4.6) OR
              CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
             target_compile_features(${MODULE_TARGET} PUBLIC ${MITK_CXX_FEATURES})
           endif()
         endif()
 
         # create export macros for all modules (also header-only)
         if (NOT MODULE_EXECUTABLE)
           set(_export_macro_name )
           if(MITK_LEGACY_EXPORT_MACRO_NAME)
             set(_export_macro_names
               EXPORT_MACRO_NAME ${MODULE_EXPORT_DEFINE}
               NO_EXPORT_MACRO_NAME ${MODULE_NAME}_NO_EXPORT
               DEPRECATED_MACRO_NAME ${MODULE_NAME}_DEPRECATED
               NO_DEPRECATED_MACRO_NAME ${MODULE_NAME}_NO_DEPRECATED
             )
           endif()
           generate_export_header(${MODULE_NAME}
             ${_export_macro_names}
             EXPORT_FILE_NAME ${MODULE_NAME}Exports.h
           )
         endif()
 
         # add include directories
         if(MODULE_INTERNAL_INCLUDE_DIRS)
           target_include_directories(${MODULE_TARGET} PRIVATE ${MODULE_INTERNAL_INCLUDE_DIRS})
         endif()
         if(NOT MODULE_NO_DEFAULT_INCDLUE_DIRS)
           if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/include)
             target_include_directories(${MODULE_TARGET} PUBLIC include)
           else()
             target_include_directories(${MODULE_TARGET} PUBLIC .)
           endif()
           if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/src)
             target_include_directories(${MODULE_TARGET} PRIVATE src)
           endif()
         endif()
         target_include_directories(${MODULE_TARGET}
           PUBLIC ${MODULE_INCLUDE_DIRS}
           PUBLIC ${CMAKE_CURRENT_BINARY_DIR}
         )
 
       endif()
     endif()
   endif()
 
   if(_MISSING_DEP)
     if(MODULE_DESCRIPTION)
       set(MODULE_DESCRIPTION "${MODULE_DESCRIPTION} (missing dependencies: ${_MISSING_DEP})")
     else()
       set(MODULE_DESCRIPTION "(missing dependencies: ${_MISSING_DEP})")
     endif()
   endif()
   if(NOT MODULE_NO_FEATURE_INFO)
     add_feature_info(${MODULE_NAME} MODULE_IS_ENABLED "${MODULE_DESCRIPTION}")
   endif()
 
   set(MODULE_NAME ${MODULE_NAME} PARENT_SCOPE)
   set(MODULE_TARGET ${MODULE_TARGET} PARENT_SCOPE)
   set(MODULE_IS_ENABLED ${MODULE_IS_ENABLED} PARENT_SCOPE)
   set(MODULE_SUBPROJECTS ${MODULE_SUBPROJECTS} PARENT_SCOPE)
 
 endfunction()
diff --git a/CMakeExternals/Boost.cmake b/CMakeExternals/Boost.cmake
index e2bc649fb7..ccb1a4bf9f 100644
--- a/CMakeExternals/Boost.cmake
+++ b/CMakeExternals/Boost.cmake
@@ -1,173 +1,173 @@
 #-----------------------------------------------------------------------------
 # Boost
 #-----------------------------------------------------------------------------
 
 if(MITK_USE_Boost)
 
   # Sanity checks
   if(DEFINED BOOST_ROOT AND NOT EXISTS ${BOOST_ROOT})
     message(FATAL_ERROR "BOOST_ROOT variable is defined but corresponds to non-existing directory")
   endif()
 
   string(REPLACE "^^" ";" MITK_USE_Boost_LIBRARIES "${MITK_USE_Boost_LIBRARIES}")
 
   set(proj Boost)
   set(proj_DEPENDENCIES )
   set(Boost_DEPENDS ${proj})
 
   if(NOT DEFINED BOOST_ROOT AND NOT MITK_USE_SYSTEM_Boost)
 
     set(_boost_libs )
     set(_with_boost_libs )
     set(_install_lib_dir )
 
     # Set the boost root to the libraries install directory
     set(BOOST_ROOT "${ep_prefix}")
 
     if(MITK_USE_Boost_LIBRARIES)
       string(REPLACE ";" "," _boost_libs "${MITK_USE_Boost_LIBRARIES}")
       foreach(_boost_lib ${MITK_USE_Boost_LIBRARIES})
         list(APPEND _with_boost_libs ${_with_boost_libs} --with-${_boost_lib})
       endforeach()
     endif()
 
     if(CMAKE_SIZEOF_VOID_P EQUAL 8)
       set(_boost_address_model "address-model=64")
     else()
       set(_boost_address_model "address-model=32")
     endif()
 
     if(WIN32)
       set(_shell_extension .bat)
       set(_boost_layout)
       if(MSVC)
         if(MSVC_VERSION EQUAL 1600)
           set(_boost_toolset "msvc-10.0")
         elseif(MSVC_VERSION EQUAL 1700)
           set(_boost_toolset "msvc-11.0")
         elseif(MSVC_VERSION EQUAL 1800)
           set(_boost_toolset "msvc-12.0")
         endif()
       endif()
       set(_install_lib_dir "--libdir=<INSTALL_DIR>/bin")
       set(WIN32_CMAKE_SCRIPT ${ep_prefix}/src/${proj}-cmake/MoveBoostLibsToLibDirForWindows.cmake)
       configure_file(${CMAKE_CURRENT_SOURCE_DIR}/CMakeExternals/MoveBoostLibsToLibDirForWindows.cmake.in ${WIN32_CMAKE_SCRIPT} @ONLY)
       set(_windows_move_libs_cmd COMMAND ${CMAKE_COMMAND} -P ${WIN32_CMAKE_SCRIPT})
     else()
       set(_shell_extension .sh)
       set(_boost_layout "--layout=tagged")
     endif()
 
     set (APPLE_SYSROOT_FLAG)
     if(APPLE)
       set(APPLE_CMAKE_SCRIPT ${ep_prefix}/src/${proj}-cmake/ChangeBoostLibsInstallNameForMac.cmake)
       configure_file(${CMAKE_CURRENT_SOURCE_DIR}/CMakeExternals/ChangeBoostLibsInstallNameForMac.cmake.in ${APPLE_CMAKE_SCRIPT} @ONLY)
       set(_macos_change_install_name_cmd COMMAND ${CMAKE_COMMAND} -P ${APPLE_CMAKE_SCRIPT})
 
       # Set OSX_SYSROOT
       if (NOT ${CMAKE_OSX_SYSROOT} STREQUAL "")
         set (APPLE_SYSROOT_FLAG --sysroot=${CMAKE_OSX_SYSROOT})
       endif()
     endif()
 
     set(_boost_variant "$<$<CONFIG:Debug>:debug>$<$<CONFIG:Release>:release>")
     set(_boost_link shared)
     if(NOT BUILD_SHARED_LIBS)
       set(_boost_link static)
     endif()
     set(_boost_cxxflags )
     if(CMAKE_CXX_FLAGS)
       set(_boost_cxxflags "cxxflags=${CMAKE_CXX_FLAGS}")
     endif()
     set(_boost_linkflags )
     if(BUILD_SHARED_LIBS AND _install_rpath_linkflag)
       set(_boost_linkflags "linkflags=${_install_rpath_linkflag}")
     endif()
 
     set(_build_cmd "<SOURCE_DIR>/b2"
         ${APPLE_SYSROOT_FLAG}
         ${_boost_layout}
         "--prefix=<INSTALL_DIR>"
         ${_install_lib_dir}
         ${_with_boost_libs}
         # Use the option below to view the shell commands (for debugging)
         #-d+4
         variant=${_boost_variant}
         link=${_boost_link}
         ${_boost_cxxflags}
         ${_boost_linkflags}
         ${_boost_address_model}
         threading=multi
         runtime-link=shared
         -q
     )
 
     if(MITK_USE_Boost_LIBRARIES)
       set(_boost_build_cmd BUILD_COMMAND ${_build_cmd})
       set(_install_cmd ${_build_cmd} install ${_macos_change_install_name_cmd} ${_windows_move_libs_cmd})
     else()
       set(_boost_build_cmd BUILD_COMMAND ${CMAKE_COMMAND} -E echo "no binary libraries")
       set(_install_cmd ${CMAKE_COMMAND} -E echo "copying Boost header..."
              COMMAND ${CMAKE_COMMAND} -E copy_directory "<SOURCE_DIR>/boost" "<INSTALL_DIR>/include/boost")
     endif()
 
     ExternalProject_Add(${proj}
       LIST_SEPARATOR ${sep}
       URL ${MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL}/boost_1_56_0.tar.bz2
       URL_MD5 a744cf167b05d72335f27c88115f211d
       # We use in-source builds for Boost
       BINARY_DIR ${ep_prefix}/src/${proj}
       CONFIGURE_COMMAND "<SOURCE_DIR>/bootstrap${_shell_extension}"
         --with-toolset=${_boost_toolset}
         --with-libraries=${_boost_libs}
-        "--prefix=<INSTALL_DIR>"
+        "--prefix=\"<INSTALL_DIR>\""
       ${_boost_build_cmd}
       INSTALL_COMMAND ${_install_cmd}
       DEPENDS ${proj_DEPENDENCIES}
       )
 
     ExternalProject_Get_Property(${proj} install_dir)
 
     if(WIN32)
       set(BOOST_LIBRARYDIR "${install_dir}/bin")
     endif()
 
     # Manual install commands (for a MITK super-build install)
     # until the Boost CMake system is used.
 
     # We just copy the include directory
     install(DIRECTORY "${install_dir}/include/boost"
             DESTINATION "include"
             COMPONENT dev
            )
 
     if(MITK_USE_Boost_LIBRARIES)
       # Copy the boost libraries
       file(GLOB _boost_libs
            "${install_dir}/lib/libboost*.so*"
            "${install_dir}/lib/libboost*.dylib")
       install(FILES ${_boost_libs}
               DESTINATION "lib"
               COMPONENT runtime)
 
       file(GLOB _boost_libs
            "${install_dir}/bin/libboost*.dll")
       install(FILES ${_boost_libs}
               DESTINATION "bin"
               COMPONENT runtime)
 
       file(GLOB _boost_libs
            "${install_dir}/lib/libboost*.lib"
            "${install_dir}/lib/libboost*.a")
       install(FILES ${_boost_libs}
               DESTINATION "lib"
               COMPONENT dev)
     endif()
 
   else()
 
     mitkMacroEmptyExternalProject(${proj} "${proj_DEPENDENCIES}")
 
   endif()
 
 endif()
diff --git a/CMakeExternals/ITK-4.5.1-gcc-4.6.patch b/CMakeExternals/ITK-4.5.1-gcc-4.6.patch
new file mode 100644
index 0000000000..0b23eebcaf
--- /dev/null
+++ b/CMakeExternals/ITK-4.5.1-gcc-4.6.patch
@@ -0,0 +1,21 @@
+diff -urNb ITK-4.5.1/Modules/ThirdParty/VNL/src/vxl/vcl/vcl_config_compiler.h.in ITK/Modules/ThirdParty/VNL/src/vxl/vcl/vcl_config_compiler.h.in
+--- ITK-4.5.1/Modules/ThirdParty/VNL/src/vxl/vcl/vcl_config_compiler.h.in	2014-02-28 19:46:45.000000000 +0100
++++ ITK/Modules/ThirdParty/VNL/src/vxl/vcl/vcl_config_compiler.h.in	2015-02-06 01:37:50.344008518 +0100
+@@ -120,7 +120,7 @@
+ // define VCL_CAN_STATIC_CONST_INIT_INT to either 0 or 1.
+ 
+ //#define VCL_CAN_STATIC_CONST_INIT_INT 1 /* allowed */
+-//#define VCL_CAN_STATIC_CONST_INIT_INT 0 /* not allowed */
++#define VCL_CAN_STATIC_CONST_INIT_INT 0 /* not allowed */
+ #ifndef VCL_CAN_STATIC_CONST_INIT_INT
+ # define VCL_CAN_STATIC_CONST_INIT_INT @VCL_STATIC_CONST_INIT_INT@
+ #endif
+@@ -144,7 +144,7 @@
+ // define VCL_CAN_STATIC_CONST_INIT_FLOAT to either 0 or 1.
+ 
+ //#define VCL_CAN_STATIC_CONST_INIT_FLOAT 1 /* allowed */
+-//#define VCL_CAN_STATIC_CONST_INIT_FLOAT 0 /* not allowed */
++#define VCL_CAN_STATIC_CONST_INIT_FLOAT 0 /* not allowed */
+ #ifndef VCL_CAN_STATIC_CONST_INIT_FLOAT
+ # define VCL_CAN_STATIC_CONST_INIT_FLOAT @VCL_STATIC_CONST_INIT_FLOAT@
+ #endif
diff --git a/CMakeExternals/ITK.cmake b/CMakeExternals/ITK.cmake
index 7233802c69..4f1f56e819 100644
--- a/CMakeExternals/ITK.cmake
+++ b/CMakeExternals/ITK.cmake
@@ -1,68 +1,76 @@
 #-----------------------------------------------------------------------------
 # ITK
 #-----------------------------------------------------------------------------
 
 # Sanity checks
 if(DEFINED ITK_DIR AND NOT EXISTS ${ITK_DIR})
   message(FATAL_ERROR "ITK_DIR variable is defined but corresponds to non-existing directory")
 endif()
 
 set(proj ITK)
 set(proj_DEPENDENCIES GDCM)
 
 if(MITK_USE_OpenCV)
   list(APPEND proj_DEPENDENCIES OpenCV)
 endif()
 
 set(ITK_DEPENDS ${proj})
 
 if(NOT DEFINED ITK_DIR)
 
   set(additional_cmake_args )
   if(MINGW)
     set(additional_cmake_args
         -DCMAKE_USE_WIN32_THREADS:BOOL=ON
         -DCMAKE_USE_PTHREADS:BOOL=OFF)
   endif()
 
   list(APPEND additional_cmake_args
        -DUSE_WRAP_ITK:BOOL=OFF
       )
 
   if(MITK_USE_OpenCV)
     list(APPEND additional_cmake_args
          -DModule_ITKVideoBridgeOpenCV:BOOL=ON
          -DOpenCV_DIR:PATH=${OpenCV_DIR}
         )
   endif()
 
   # Keep the behaviour of ITK 4.3 which by default turned on ITK Review
   # see MITK bug #17338
   list(APPEND additional_cmake_args
     -DModule_ITKReview:BOOL=ON
   )
 
+  set(vcl_constexpr_patch)
+  if(GCC_VERSION VERSION_LESS 4.7 AND GCC_VERSION VERSION_GREATER 4)
+    set(vcl_constexpr_patch
+      COMMAND ${PATCH_COMMAND} -N -p1 -i ${CMAKE_CURRENT_LIST_DIR}/ITK-4.5.1-gcc-4.6.patch
+    )
+  endif()
+
   ExternalProject_Add(${proj}
      LIST_SEPARATOR ${sep}
      URL ${MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL}/InsightToolkit-4.5.1-3e550bf8.tar.gz
      URL_MD5 80e433ffc0e81cdc19a03dd02a3c329b
      # work with external GDCM
      PATCH_COMMAND ${PATCH_COMMAND} -N -p1 -i ${CMAKE_CURRENT_LIST_DIR}/ITK-4.5.1.patch
+                   ${vcl_constexpr_patch}
      CMAKE_GENERATOR ${gen}
      CMAKE_ARGS
        ${ep_common_args}
        ${additional_cmake_args}
        -DBUILD_EXAMPLES:BOOL=OFF
        -DITK_USE_SYSTEM_GDCM:BOOL=ON
        -DGDCM_DIR:PATH=${GDCM_DIR}
      DEPENDS ${proj_DEPENDENCIES}
     )
 
   set(ITK_DIR ${ep_prefix})
   mitkFunctionInstallExternalCMakeProject(${proj})
 
 else()
 
   mitkMacroEmptyExternalProject(${proj} "${proj_DEPENDENCIES}")
 
 endif()
diff --git a/CMakeLists.txt b/CMakeLists.txt
index f15022a555..5ba0cb9003 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,1277 +1,1300 @@
 set(MITK_CMAKE_MINIMUM_REQUIRED_VERSION 3.1)
 cmake_minimum_required(VERSION ${MITK_CMAKE_MINIMUM_REQUIRED_VERSION})
 
 #-----------------------------------------------------------------------------
-# Set a default build type if none was specified
+# See http://cmake.org/cmake/help/cmake-2-8-docs.html#section_Policies for details
 #-----------------------------------------------------------------------------
 
-if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
-  message(STATUS "Setting build type to 'Debug' as none was specified.")
-  set(CMAKE_BUILD_TYPE Debug CACHE STRING "Choose the type of build." FORCE)
-
-  # Set the possible values of build type for cmake-gui
-  set_property(CACHE CMAKE_BUILD_TYPE PROPERTY
-               STRINGS "Debug" "Release" "MinSizeRel" "RelWithDebInfo")
-endif()
+set(project_policies )
+foreach(policy ${project_policies})
+  if(POLICY ${policy})
+    cmake_policy(SET ${policy} NEW)
+  endif()
+endforeach()
 
 #-----------------------------------------------------------------------------
 # 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 VERSION 2014.10.99)
 endif()
 
+#-----------------------------------------------------------------------------
+# Update CMake module path
+#------------------------------------------------------------------------------
+
+set(MITK_CMAKE_DIR ${MITK_SOURCE_DIR}/CMake)
+
+set(CMAKE_MODULE_PATH
+  ${MITK_CMAKE_DIR}
+  ${CMAKE_MODULE_PATH}
+  )
+
+#-----------------------------------------------------------------------------
+# CMake function(s) and macro(s)
+#-----------------------------------------------------------------------------
+
+# Standard CMake macros
+include(FeatureSummary)
+include(CTestUseLaunchers)
+include(CMakeParseArguments)
+include(FindPackageHandleStandardArgs)
+
+# MITK macros
+include(mitkFunctionGetGccVersion)
+include(mitkFunctionCheckCompilerFlags)
+include(mitkFunctionSuppressWarnings) # includes several functions
+include(mitkMacroEmptyExternalProject)
+include(mitkFunctionGenerateProjectXml)
+include(mitkFunctionEnableBuildConfiguration)
+include(mitkFunctionWhitelists)
+include(mitkFunctionAddExternalProject)
+
+SUPPRESS_VC_DEPRECATED_WARNINGS()
+
+#-----------------------------------------------------------------------------
+# Set a default build type if none was specified
+#-----------------------------------------------------------------------------
+
+if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
+  message(STATUS "Setting build type to 'Debug' as none was specified.")
+  set(CMAKE_BUILD_TYPE Debug CACHE STRING "Choose the type of build." FORCE)
+
+  # Set the possible values of build type for cmake-gui
+  set_property(CACHE CMAKE_BUILD_TYPE PROPERTY
+               STRINGS "Debug" "Release" "MinSizeRel" "RelWithDebInfo")
+endif()
+
 #-----------------------------------------------------------------------------
 # Check miminum compiler versions
 #-----------------------------------------------------------------------------
 
 if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
   # require at least gcc 4.6 as provided by Ubuntu 12.04
   if (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.6)
     message(FATAL_ERROR "GCC version must be at least 4.6")
   endif()
 elseif("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
   # require at least clang 3.2 for correct RTTI handling and C++11 support
   if (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 3.2)
     message(FATAL_ERROR "Clang version must be at least 3.2")
   endif()
 elseif("${CMAKE_CXX_COMPILER_ID}" STREQUAL "AppleClang")
   # require at least clang 5.0
   if (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 5.0)
     message(FATAL_ERROR "Apple Clang version must be at least 5.0")
   endif()
 elseif("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
   # require at least Visual Studio 2010 (msvc ...)
   if (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 16)
     message(FATAL_ERROR "Micorsoft Visual Studio 2010 or newer required (MSVC 16.0)")
   endif()
 else()
   message(WARNING "You are using an unsupported compiler! Compilation has only been tested with Clang (Linux or Apple), GCC and MSVC.")
 endif()
 
+if(CMAKE_COMPILER_IS_GNUCXX)
+  mitkFunctionGetGccVersion(${CMAKE_CXX_COMPILER} GCC_VERSION)
+else()
+  set(GCC_VERSION 0)
+endif()
+
+set(MITK_CXX_STANDARD 11)
+
+# help keeping cross-platform compatibility
+# CMake 3.1 does not yet know how to handle AppleClang...
+# See http://public.kitware.com/Bug/view.php?id=15355
+if(NOT MSVC AND
+   NOT CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang" AND
+   GCC_VERSION VERSION_GREATER 4.6)
+  set(CMAKE_CXX_EXTENSIONS 0)
+  set(CMAKE_CXX_STANDARD ${MITK_CXX_STANDARD})
+  set(CMAKE_CXX_STANDARD_REQUIRED 1)
+endif()
+
+# This is necessary to avoid problems with compile feature checks.
+# CMAKE_CXX_STANDARD seems to only set the -std=c++11 flag for targets.
+# However, compile flag checks also need to be done with -std=c++11.
+# The MITK_CXX11_FLAG variable is also used for external projects
+# build during the MITK super-build.
+mitkFunctionCheckCompilerFlags("-std=c++11" MITK_CXX11_FLAG)
+if(NOT MITK_CXX11_FLAG)
+  # Older gcc compilers use -std=c++0x
+  mitkFunctionCheckCompilerFlags("-std=c++0x" MITK_CXX11_FLAG)
+endif()
+
 #-----------------------------------------------------------------------------
 # Warn if source or build path is too long
 #-----------------------------------------------------------------------------
 
 if(WIN32)
   set(_src_dir_length_max 50)
   set(_bin_dir_length_max 50)
   if(MITK_USE_SUPERBUILD)
     set(_src_dir_length_max 43) # _src_dir_length_max - strlen(ITK-src)
     set(_bin_dir_length_max 40) # _bin_dir_length_max - strlen(MITK-build)
   endif()
 
   string(LENGTH "${MITK_SOURCE_DIR}" _src_n)
   string(LENGTH "${MITK_BINARY_DIR}" _bin_n)
 
   # The warnings should be converted to errors
   if(_src_n GREATER _src_dir_length_max)
     message(WARNING "MITK source code directory path length is too long (${_src_n} > ${_src_dir_length_max})."
                     "Please move the MITK source code directory to a directory with a shorter path." )
   endif()
   if(_bin_n GREATER _bin_dir_length_max)
     message(WARNING "MITK build directory path length is too long (${_bin_n} > ${_bin_dir_length_max})."
                     "Please move the MITK build directory to a directory with a shorter path." )
   endif()
 endif()
 
-#-----------------------------------------------------------------------------
-# See http://cmake.org/cmake/help/cmake-2-8-docs.html#section_Policies for details
-#-----------------------------------------------------------------------------
-
-set(project_policies )
-foreach(policy ${project_policies})
-  if(POLICY ${policy})
-    cmake_policy(SET ${policy} NEW)
-  endif()
-endforeach()
-
-#-----------------------------------------------------------------------------
-# Update CMake module path
-#------------------------------------------------------------------------------
-
-set(MITK_CMAKE_DIR ${MITK_SOURCE_DIR}/CMake)
-
-set(CMAKE_MODULE_PATH
-  ${MITK_CMAKE_DIR}
-  ${CMAKE_MODULE_PATH}
-  )
-
-#-----------------------------------------------------------------------------
-# CMake function(s) and macro(s)
-#-----------------------------------------------------------------------------
-
-# Standard CMake macros
-include(FeatureSummary)
-include(CTestUseLaunchers)
-include(CMakeParseArguments)
-include(FindPackageHandleStandardArgs)
-
-# MITK macros
-include(mitkMacroEmptyExternalProject)
-include(mitkFunctionGenerateProjectXml)
-include(mitkFunctionSuppressWarnings)
-include(mitkFunctionEnableBuildConfiguration)
-include(mitkFunctionWhitelists)
-include(mitkFunctionAddExternalProject)
-
-SUPPRESS_VC_DEPRECATED_WARNINGS()
-
 #-----------------------------------------------------------------------------
 # Additional MITK Options (also shown during superbuild)
 #-----------------------------------------------------------------------------
 
 macro(env_option name doc value)
   set(_value $ENV{${name}})
   if("${_value}" STREQUAL "")
     set(_value ${value})
   endif()
   option(${name} "${doc}" ${_value})
 endmacro()
 
 # -----------------------------------------
 # General build options
 option(BUILD_SHARED_LIBS "Build MITK with shared libraries" ON)
 option(WITH_COVERAGE "Enable/Disable coverage" OFF)
 option(BUILD_TESTING "Test the project" ON)
 
 env_option(MITK_BUILD_ALL_APPS "Build all MITK applications" OFF)
 env_option(MITK_BUILD_EXAMPLES "Build the MITK Examples" OFF)
 option(MITK_ENABLE_PIC_READER "Enable support for reading the DKFZ pic file format." ON)
 
 mark_as_advanced(MITK_BUILD_ALL_APPS
                  MITK_ENABLE_PIC_READER
                 )
 
 # -----------------------------------------
 # Qt version related variables
 
 set(DESIRED_QT_VERSION 4 CACHE STRING "Pick a version of Qt to use: 4 or 5")
 env_option(MITK_USE_QT "Use Nokia's Qt library" ON)
 set(MITK_DESIRED_QT_VERSION ${DESIRED_QT_VERSION})
 
 if(MITK_USE_QT)
   # find the package at the very beginning, so that QT4_FOUND is available
   if(DESIRED_QT_VERSION MATCHES 4)
     set(MITK_QT4_MINIMUM_VERSION 4.7)
     find_package(Qt4 ${MITK_QT4_MINIMUM_VERSION} REQUIRED)
     set(MITK_USE_Qt4 TRUE)
     set(MITK_USE_Qt5 FALSE)
   endif()
   if(DESIRED_QT_VERSION MATCHES 5)
     set(MITK_QT5_MINIMUM_VERSION 5.0.0)
     set(MITK_USE_Qt4 FALSE)
     set(MITK_USE_Qt5 TRUE)
     set(QT5_INSTALL_PREFIX "" CACHE PATH "The install location of Qt5")
     set(CMAKE_PREFIX_PATH ${CMAKE_PREFIX_PATH} ${QT5_INSTALL_PREFIX})
     set(MITK_QT5_COMPONENTS Concurrent OpenGL PrintSupport Script Sql Svg WebKitWidgets Xml XmlPatterns UiTools)
     find_package(Qt5 ${MITK_QT5_MINIMUM_VERSION} COMPONENTS ${MITK_QT5_COMPONENTS} REQUIRED)
   endif()
 else()
   set(MITK_USE_Qt4 FALSE)
   set(MITK_USE_Qt5 FALSE)
 endif()
 
 # ------------------------------------------------------------------------
 # Register external projects which can be build with the MITK superbuild
 # system. Each mitkFunctionAddExternalProject() call registers an external
 # project for which a CMakeExternals/<project>.cmake file must exist. The
 # call also creates a MITK_USE_<project> variable (appearing in the CMake
 # UI if the NO_CACHE option is *not* given).
 
 
 # -----------------------------------------
 # Optional external projects with no
 # inter-dependencies
 
 set_property(GLOBAL PROPERTY MITK_EXTERNAL_PROJECTS "")
 
 mitkFunctionAddExternalProject(NAME Poco        ON  COMPONENTS Foundation Util XML)
 mitkFunctionAddExternalProject(NAME Boost       OFF DOC "Use the Boost C++ library")
 mitkFunctionAddExternalProject(NAME DCMTK       ON  DOC "EXPERIMENTAL, superbuild only: Use DCMTK in MITK")
 mitkFunctionAddExternalProject(NAME OpenIGTLink OFF)
 
 mitkFunctionAddExternalProject(NAME tinyxml     ON  ADVANCED)
 mitkFunctionAddExternalProject(NAME GDCM        ON  ADVANCED)
 mitkFunctionAddExternalProject(NAME GLUT        OFF ADVANCED)
 mitkFunctionAddExternalProject(NAME Raptor2     OFF ADVANCED)
 mitkFunctionAddExternalProject(NAME Eigen       ON  ADVANCED DOC "Use the Eigen library")
 mitkFunctionAddExternalProject(NAME GLEW        ON  ADVANCED DOC "Use the GLEW library")
 mitkFunctionAddExternalProject(NAME ANN         ON  ADVANCED DOC "Use Approximate Nearest Neighbor Library")
 mitkFunctionAddExternalProject(NAME CppUnit     ON  ADVANCED DOC "Use CppUnit for unit tests")
 
 mitkFunctionAddExternalProject(NAME PCRE        OFF ADVANCED NO_PACKAGE)
 mitkFunctionAddExternalProject(NAME ZLIB        OFF ADVANCED NO_PACKAGE NO_CACHE)
 
 # -----------------------------------------
 # The following external projects must be
 # ordered according to their
 # inter-dependencies
 
 if(MITK_USE_QT)
   mitkFunctionAddExternalProject(NAME Qwt     ON  ADVANCED)
 endif()
 
 mitkFunctionAddExternalProject(NAME SWIG      OFF ADVANCED NO_PACKAGE DEPENDS PCRE)
 mitkFunctionAddExternalProject(NAME Python    OFF          NO_PACKAGE DEPENDS SWIG DOC "Use Python wrapping in MITK")
 mitkFunctionAddExternalProject(NAME Numpy     OFF ADVANCED NO_PACKAGE)
 mitkFunctionAddExternalProject(NAME OpenCV    OFF)
 
 # These are "hard" dependencies and always set to ON
 mitkFunctionAddExternalProject(NAME ITK       ON           NO_CACHE)
 mitkFunctionAddExternalProject(NAME VTK       ON           NO_CACHE)
 
 mitkFunctionAddExternalProject(NAME SimpleITK OFF          DEPENDS ITK GDCM SWIG)
 mitkFunctionAddExternalProject(NAME ACVD      OFF          DOC "Use Approximated Centroidal Voronoi Diagrams")
 mitkFunctionAddExternalProject(NAME CTK       ON           DEPENDS DCMTK DOC "Use CTK in MITK")
 mitkFunctionAddExternalProject(NAME Rasqal    OFF          DEPENDS Raptor2 PCRE ADVANCED)
 mitkFunctionAddExternalProject(NAME Redland   OFF          DEPENDS Rasqal DOC "Use the Redland RDF library")
 mitkFunctionAddExternalProject(NAME SOFA      OFF          DEPENDS GLUT Boost DOC "Use Simulation Open Framework Architecture")
 
+#-----------------------------------------------------------------------------
+# Build configurations
+#-----------------------------------------------------------------------------
+
+set(_buildConfigs "Custom")
+
+file(GLOB _buildConfigFiles CMake/BuildConfigurations/*.cmake)
+
+foreach(_buildConfigFile ${_buildConfigFiles})
+  get_filename_component(_buildConfigFile ${_buildConfigFile} NAME_WE)
+  list(APPEND _buildConfigs ${_buildConfigFile})
+endforeach()
+
+set(MITK_BUILD_CONFIGURATION "Custom" CACHE STRING "Use pre-defined MITK configurations")
+mark_as_advanced(MITK_BUILD_CONFIGURATION)
+set_property(CACHE MITK_BUILD_CONFIGURATION PROPERTY STRINGS ${_buildConfigs})
+
+mitkFunctionEnableBuildConfiguration()
+
+mitkFunctionCreateWhitelistPaths(MITK)
+mitkFunctionFindWhitelists(MITK)
+
 # -----------------------------------------
 # Custom dependency logic
 
 if(MITK_USE_Boost)
   option(MITK_USE_SYSTEM_Boost "Use the system Boost" OFF)
   set(MITK_USE_Boost_LIBRARIES "" CACHE STRING "A semi-colon separated list of required Boost libraries")
 endif()
 
 if(MITK_USE_SOFA)
   # SOFA requires at least CMake 2.8.8
   set(SOFA_CMAKE_VERSION 2.8.8)
   if(${CMAKE_VERSION} VERSION_LESS ${SOFA_CMAKE_VERSION})
     set(MITK_USE_SOFA OFF CACHE BOOL "" FORCE)
     message(WARNING "Switched off MITK_USE_SOFA\n  Minimum required CMake version: ${SOFA_CMAKE_VERSION}\n  Installed CMake version: ${CMAKE_VERSION}")
   endif()
   # SOFA/ITK combination requires at least MSVC 2010
   if(MSVC_VERSION AND MSVC_VERSION LESS 1600)
     set(MITK_USE_SOFA OFF CACHE BOOL "" FORCE)
     message(WARNING "Switched off MITK_USE_SOFA\n  MSVC versions less than 2010 are not supported.")
   endif()
   # SOFA requires boost library
   if(MITK_USE_SOFA AND NOT MITK_USE_Boost)
     message("> Forcing MITK_USE_Boost to ON because of MITK_USE_SOFA")
     set(MITK_USE_Boost ON CACHE BOOL "" FORCE)
   endif()
   # SOFA requires boost system library
   list(FIND MITK_USE_Boost_LIBRARIES system _result)
   if(_result LESS 0)
     message("> Adding 'system' to MITK_USE_Boost_LIBRARIES.")
     list(APPEND MITK_USE_Boost_LIBRARIES system)
   endif()
   # SOFA requires boost thread library
   list(FIND MITK_USE_Boost_LIBRARIES thread _result)
   if(_result LESS 0)
     message("> Adding 'thread' to MITK_USE_Boost_LIBRARIES.")
     list(APPEND MITK_USE_Boost_LIBRARIES thread)
   endif()
   # Simulation plugin requires boost chrono library
   list(FIND MITK_USE_Boost_LIBRARIES chrono _result)
   if(_result LESS 0)
     message("> Adding 'chrono' to MITK_USE_Boost_LIBRARIES.")
     list(APPEND MITK_USE_Boost_LIBRARIES chrono)
   endif()
   set(MITK_USE_Boost_LIBRARIES ${MITK_USE_Boost_LIBRARIES} CACHE STRING "" FORCE)
   # Allow setting external SOFA plugins directory and SOFA plugins
   set(MITK_USE_SOFA_PLUGINS_DIR ${MITK_USE_SOFA_PLUGINS_DIR} CACHE PATH "External SOFA plugins directory" FORCE)
   set(MITK_USE_SOFA_PLUGINS ${MITK_USE_SOFA_PLUGINS} CACHE PATH "List of semicolon-separated plugin names" FORCE)
 endif()
 
 if(MITK_USE_Python AND NOT MITK_USE_SYSTEM_PYTHON)
   set(MITK_USE_ZLIB ON)
   if(NOT MITK_USE_Numpy)
     message("> Forcing MITK_USE_Numpy to ON because of MITK_USE_Python")
     set(MITK_USE_Numpy ON CACHE BOOL "Use Numpy" FORCE)
   endif()
   if(NOT MITK_USE_SimpleITK)
     message("> Forcing MITK_USE_SimpleITK to ON because of MITK_USE_Python")
     set(MITK_USE_Numpy ON CACHE BOOL "Use Numpy" FORCE)
   endif()
 
   if(APPLE)
     message(WARNING "Python wrapping is unsuported on mac OSX!")
     set(MITK_USE_Python OFF CACHE BOOL "Use Python wrapping in MITK" FORCE)
   else()
     option(MITK_USE_SYSTEM_PYTHON "Use the system python runtime" OFF)
     if(MITK_USE_SYSTEM_PYTHON)
       find_package(PythonLibs REQUIRED)
       find_package(PythonInterp REQUIRED)
     endif()
   endif()
 endif()
 
 if(BUILD_TESTING AND NOT MITK_USE_CppUnit)
   message("> Forcing MITK_USE_CppUnit to ON because BUILD_TESTING=ON")
   set(MITK_USE_CppUnit ON CACHE BOOL "Use CppUnit for unit tests" FORCE)
 endif()
 
 # -----------------------------------------
 # Other MITK_USE_* options not related to
 # external projects build via the
 # MITK superbuild
 
 env_option(MITK_USE_BLUEBERRY "Build the BlueBerry platform" ON)
 env_option(MITK_USE_OpenCL "Use OpenCL GPU-Computing library" OFF)
 
 if(MITK_USE_BLUEBERRY)
   option(MITK_BUILD_ALL_PLUGINS "Build all MITK plugins" OFF)
   mark_as_advanced(MITK_BUILD_ALL_PLUGINS)
 
   if(NOT MITK_USE_CTK)
     message("> Forcing MITK_USE_CTK to ON because of MITK_USE_BLUEBERRY")
     set(MITK_USE_CTK ON CACHE BOOL "Use CTK in MITK" FORCE)
   endif()
 endif()
 
-#-----------------------------------------------------------------------------
-# Build configurations
-#-----------------------------------------------------------------------------
-
-set(_buildConfigs "Custom")
-
-file(GLOB _buildConfigFiles CMake/BuildConfigurations/*.cmake)
-
-foreach(_buildConfigFile ${_buildConfigFiles})
-  get_filename_component(_buildConfigFile ${_buildConfigFile} NAME_WE)
-  list(APPEND _buildConfigs ${_buildConfigFile})
-endforeach()
-
-set(MITK_BUILD_CONFIGURATION "Custom" CACHE STRING "Use pre-defined MITK configurations")
-mark_as_advanced(MITK_BUILD_CONFIGURATION)
-set_property(CACHE MITK_BUILD_CONFIGURATION PROPERTY STRINGS ${_buildConfigs})
-
-mitkFunctionEnableBuildConfiguration()
-
-mitkFunctionCreateWhitelistPaths(MITK)
-mitkFunctionFindWhitelists(MITK)
-
 #-----------------------------------------------------------------------------
 # Pixel type multiplexing
 #-----------------------------------------------------------------------------
 
 # Customize the default pixel types for multiplex macros
 
 set(MITK_ACCESSBYITK_INTEGRAL_PIXEL_TYPES
     "int, unsigned int, short, unsigned short, char, unsigned char"
     CACHE STRING "List of integral pixel types used in AccessByItk and InstantiateAccessFunction macros")
 
 set(MITK_ACCESSBYITK_FLOATING_PIXEL_TYPES
     "double, float"
     CACHE STRING "List of floating pixel types used in AccessByItk and InstantiateAccessFunction macros")
 
 set(MITK_ACCESSBYITK_COMPOSITE_PIXEL_TYPES
     "itk::RGBPixel<unsigned char>, itk::RGBAPixel<unsigned char>"
     CACHE STRING "List of composite pixel types used in AccessByItk and InstantiateAccessFunction macros")
 
 set(MITK_ACCESSBYITK_DIMENSIONS
     "2,3"
     CACHE STRING "List of dimensions used in AccessByItk and InstantiateAccessFunction macros")
 
 mark_as_advanced(MITK_ACCESSBYITK_INTEGRAL_PIXEL_TYPES
                  MITK_ACCESSBYITK_FLOATING_PIXEL_TYPES
                  MITK_ACCESSBYITK_COMPOSITE_PIXEL_TYPES
                  MITK_ACCESSBYITK_DIMENSIONS
                 )
 
 # consistency checks
 
 if(NOT MITK_ACCESSBYITK_INTEGRAL_PIXEL_TYPES)
   set(MITK_ACCESSBYITK_INTEGRAL_PIXEL_TYPES
       "int, unsigned int, short, unsigned short, char, unsigned char"
       CACHE STRING "List of integral pixel types used in AccessByItk and InstantiateAccessFunction macros" FORCE)
 endif()
 
 if(NOT MITK_ACCESSBYITK_FLOATING_PIXEL_TYPES)
   set(MITK_ACCESSBYITK_FLOATING_PIXEL_TYPES
       "double, float"
       CACHE STRING "List of floating pixel types used in AccessByItk and InstantiateAccessFunction macros" FORCE)
 endif()
 
 if(NOT MITK_ACCESSBYITK_COMPOSITE_PIXEL_TYPES)
   set(MITK_ACCESSBYITK_COMPOSITE_PIXEL_TYPES
     "itk::RGBPixel<unsigned char>, itk::RGBAPixel<unsigned char>"
     CACHE STRING "List of composite pixel types used in AccessByItk and InstantiateAccessFunction macros" FORCE)
 endif()
 
 if(NOT MITK_ACCESSBYITK_VECTOR_PIXEL_TYPES)
   string(REPLACE "," ";" _integral_types ${MITK_ACCESSBYITK_INTEGRAL_PIXEL_TYPES})
   string(REPLACE "," ";" _floating_types ${MITK_ACCESSBYITK_FLOATING_PIXEL_TYPES})
   foreach(_scalar_type ${_integral_types} ${_floating_types})
     set(MITK_ACCESSBYITK_VECTOR_PIXEL_TYPES
         "${MITK_ACCESSBYITK_VECTOR_PIXEL_TYPES}itk::VariableLengthVector<${_scalar_type}>,")
   endforeach()
   string(LENGTH "${MITK_ACCESSBYITK_VECTOR_PIXEL_TYPES}" _length)
   math(EXPR _length "${_length} - 1")
   string(SUBSTRING "${MITK_ACCESSBYITK_VECTOR_PIXEL_TYPES}" 0 ${_length} MITK_ACCESSBYITK_VECTOR_PIXEL_TYPES)
   set(MITK_ACCESSBYITK_VECTOR_PIXEL_TYPES ${MITK_ACCESSBYITK_VECTOR_PIXEL_TYPES}
       CACHE STRING "List of vector pixel types used in AccessByItk and InstantiateAccessFunction macros for itk::VectorImage types" FORCE)
 endif()
 
 if(NOT MITK_ACCESSBYITK_DIMENSIONS)
   set(MITK_ACCESSBYITK_DIMENSIONS
       "2,3"
       CACHE STRING "List of dimensions used in AccessByItk and InstantiateAccessFunction macros")
 endif()
 
 #-----------------------------------------------------------------------------
 # 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
   MITK-Examples
   Unlabeled # special "subproject" catching all unlabeled targets and tests
   )
 
 # Configure CTestConfigSubProject.cmake that could be used by CTest scripts
 configure_file(${MITK_SOURCE_DIR}/CTestConfigSubProject.cmake.in
                ${MITK_BINARY_DIR}/CTestConfigSubProject.cmake)
 
 if(CTEST_PROJECT_ADDITIONAL_TARGETS)
   # those targets will be executed at the end of the ctest driver script
   # and they also get their own subproject label
   set(subproject_list "${CTEST_PROJECT_SUBPROJECTS};${CTEST_PROJECT_ADDITIONAL_TARGETS}")
 else()
   set(subproject_list "${CTEST_PROJECT_SUBPROJECTS}")
 endif()
 
 # Generate Project.xml file expected by the CTest driver script
 mitkFunctionGenerateProjectXml(${MITK_BINARY_DIR} MITK "${subproject_list}" ${MITK_USE_SUPERBUILD})
 
 #-----------------------------------------------------------------------------
 # Superbuild script
 #-----------------------------------------------------------------------------
 
 if(MITK_USE_SUPERBUILD)
   include("${CMAKE_CURRENT_SOURCE_DIR}/SuperBuild.cmake")
 
   # Print configuration summary
   message("\n\n")
   feature_summary(
     DESCRIPTION "------- FEATURE SUMMARY FOR ${PROJECT_NAME} -------"
     WHAT ALL)
   return()
 endif()
 
 #*****************************************************************************
 #****************************  END OF SUPERBUILD  ****************************
 #*****************************************************************************
 
 #-----------------------------------------------------------------------------
 # CMake function(s) and macro(s)
 #-----------------------------------------------------------------------------
 
 include(WriteBasicConfigVersionFile)
 include(CheckCXXSourceCompiles)
 include(GenerateExportHeader)
-include(mitkFunctionCheckCompilerFlags)
-include(mitkFunctionGetGccVersion)
-include(mitkFunctionSuppressWarnings) # includes several functions
 include(mitkFunctionOrganizeSources)
 include(mitkFunctionGetVersion)
 include(mitkFunctionGetVersionDescription)
 include(mitkFunctionCreateWindowsBatchScript)
 include(mitkFunctionInstallProvisioningFiles)
 include(mitkFunctionInstallAutoLoadModules)
 include(mitkFunctionGetLibrarySearchPaths)
 include(mitkFunctionCompileSnippets)
 include(mitkFunctionUseModules)
 include(mitkFunctionCheckModuleDependencies)
 include(mitkFunctionCreateModule)
 include(mitkMacroCreateExecutable)
 include(mitkMacroCreateModuleTests)
 include(mitkFunctionAddCustomModuleTest)
 include(mitkMacroMultiplexPicType)
 include(mitkMacroInstall)
 include(mitkMacroInstallHelperApp)
 include(mitkMacroInstallTargets)
 include(mitkMacroGenerateToolsLibrary)
 include(mitkMacroGetLinuxDistribution)
 include(mitkMacroGetPMDPlatformString)
 include(mitkMacroConfigureItkPixelTypes)
 
 #-----------------------------------------------------------------------------
 # Global CMake variables
 #-----------------------------------------------------------------------------
 
-set(MITK_CXX_STANDARD 11)
-
-# help keeping cross-platform compatibility
-# CMake 3.1 does not yet know how to handle AppleClang...
-# See http://public.kitware.com/Bug/view.php?id=15355
-if(NOT MSVC AND NOT CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang")
-  set(CMAKE_CXX_EXTENSIONS 0)
-  set(CMAKE_CXX_STANDARD ${MITK_CXX_STANDARD})
-  set(CMAKE_CXX_STANDARD_REQUIRED 1)
-endif()
-
 # Required and enabled C++11 features for all MITK code.
 # These are added as PUBLIC compile features to all MITK modules.
 set(MITK_CXX_FEATURES cxx_auto_type cxx_nullptr cxx_override)
 
 if(NOT DEFINED CMAKE_DEBUG_POSTFIX)
   # We can't do this yet because the CTK Plugin Framework
   # cannot cope with a postfix yet.
   #set(CMAKE_DEBUG_POSTFIX d)
 endif()
 
 #-----------------------------------------------------------------------------
 # Output directories.
 #-----------------------------------------------------------------------------
 
 set(_default_LIBRARY_output_dir lib)
 set(_default_RUNTIME_output_dir bin)
 set(_default_ARCHIVE_output_dir lib)
 
 foreach(type LIBRARY RUNTIME ARCHIVE)
   # Make sure the directory exists
   if(MITK_CMAKE_${type}_OUTPUT_DIRECTORY
      AND NOT EXISTS ${MITK_CMAKE_${type}_OUTPUT_DIRECTORY})
     message("Creating directory MITK_CMAKE_${type}_OUTPUT_DIRECTORY: ${MITK_CMAKE_${type}_OUTPUT_DIRECTORY}")
     file(MAKE_DIRECTORY "${MITK_CMAKE_${type}_OUTPUT_DIRECTORY}")
   endif()
 
   if(MITK_CMAKE_${type}_OUTPUT_DIRECTORY)
     set(CMAKE_${type}_OUTPUT_DIRECTORY ${MITK_CMAKE_${type}_OUTPUT_DIRECTORY})
   else()
     set(CMAKE_${type}_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/${_default_${type}_output_dir})
     set(MITK_CMAKE_${type}_OUTPUT_DIRECTORY ${CMAKE_${type}_OUTPUT_DIRECTORY})
   endif()
 
   set(CMAKE_${type}_OUTPUT_DIRECTORY ${CMAKE_${type}_OUTPUT_DIRECTORY} CACHE INTERNAL "Output directory for ${type} files.")
   mark_as_advanced(CMAKE_${type}_OUTPUT_DIRECTORY)
 endforeach()
 
 #-----------------------------------------------------------------------------
 # Set MITK specific options and variables (NOT available during superbuild)
 #-----------------------------------------------------------------------------
 
 # ASK THE USER TO SHOW THE CONSOLE WINDOW FOR CoreApp and mitkWorkbench
 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)
 
 if(NOT MITK_FAST_TESTING)
   if(DEFINED MITK_CTEST_SCRIPT_MODE
       AND (MITK_CTEST_SCRIPT_MODE STREQUAL "continuous" OR MITK_CTEST_SCRIPT_MODE STREQUAL "experimental") )
     set(MITK_FAST_TESTING 1)
   endif()
 endif()
 
 # MITK_VERSION
 set(MITK_VERSION_STRING "${MITK_VERSION_MAJOR}.${MITK_VERSION_MINOR}.${MITK_VERSION_PATCH}")
 if(MITK_VERSION_PATCH STREQUAL "99")
   set(MITK_VERSION_STRING "${MITK_VERSION_STRING}-${MITK_REVISION_SHORTID}")
 endif()
 
 # Needed early on for redirecting the BlueBerry documentation output dir
 set(MITK_DOXYGEN_OUTPUT_DIR ${PROJECT_BINARY_DIR}/Documentation/Doxygen CACHE PATH
     "Output directory for doxygen generated documentation." )
 
 if(NOT UNIX AND NOT MINGW)
   set(MITK_WIN32_FORCE_STATIC "STATIC" CACHE INTERNAL "Use this variable to always build static libraries on non-unix platforms")
 endif()
 
 if(MITK_BUILD_ALL_PLUGINS)
   set(MITK_BUILD_ALL_PLUGINS_OPTION "FORCE_BUILD_ALL")
 endif()
 
 # Configure pixel types used for ITK image access multiplexing
 mitkMacroConfigureItkPixelTypes()
 
 # Configure module naming conventions
 set(MITK_MODULE_NAME_REGEX_MATCH "^[A-Z].*$")
 set(MITK_MODULE_NAME_REGEX_NOT_MATCH "^[Mm][Ii][Tt][Kk].*$")
 set(MITK_MODULE_NAME_PREFIX "Mitk")
 set(MITK_MODULE_NAME_DEFAULTS_TO_DIRECTORY_NAME 1)
 
 #-----------------------------------------------------------------------------
 # Get MITK version info
 #-----------------------------------------------------------------------------
 
 mitkFunctionGetVersion(${MITK_SOURCE_DIR} MITK)
 mitkFunctionGetVersionDescription(${MITK_SOURCE_DIR} MITK)
 
 #-----------------------------------------------------------------------------
 # Installation preparation
 #
 # These should be set before any MITK install macros are used
 #-----------------------------------------------------------------------------
 
 # on Mac OSX all BlueBerry plugins get copied into every
 # application bundle (.app directory) specified here
 if(MITK_USE_BLUEBERRY AND APPLE)
 
   include("${CMAKE_CURRENT_SOURCE_DIR}/Applications/AppList.cmake")
 
   foreach(mitk_app ${MITK_APPS})
     # extract option_name
     string(REPLACE "^^" "\\;" target_info ${mitk_app})
     set(target_info_list ${target_info})
     list(GET target_info_list 1 option_name)
     list(GET target_info_list 0 app_name)
     # check if the application is enabled
     if(${option_name} OR MITK_BUILD_ALL_APPS)
       set(MACOSX_BUNDLE_NAMES ${MACOSX_BUNDLE_NAMES} Mitk${app_name})
     endif()
   endforeach()
 
 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}")
 set(MITK_C_FLAGS_DEBUG )
 set(MITK_C_FLAGS_RELEASE )
-set(MITK_CXX_FLAGS "${COVERAGE_CXX_FLAGS}")
+set(MITK_CXX_FLAGS "${COVERAGE_CXX_FLAGS} ${MITK_CXX11_FLAG}")
 set(MITK_CXX_FLAGS_DEBUG )
 set(MITK_CXX_FLAGS_RELEASE )
 
 set(MITK_EXE_LINKER_FLAGS )
 set(MITK_SHARED_LINKER_FLAGS )
 
-mitkFunctionCheckCompilerFlags("-std=c++11" MITK_CXX_FLAGS)
-
 if(WIN32)
   set(MITK_CXX_FLAGS "${MITK_CXX_FLAGS} -D_WIN32_WINNT=0x0501 -DPOCO_NO_UNWINDOWS -DWIN32_LEAN_AND_MEAN -DNOMINMAX")
   mitkFunctionCheckCompilerFlags("/wd4005" MITK_CXX_FLAGS) # warning C4005: macro redefinition
   mitkFunctionCheckCompilerFlags("/wd4231" MITK_CXX_FLAGS) # warning C4231: nonstandard extension used : 'extern' before template explicit instantiation
   # the following line should be removed after fixing bug 17637
   mitkFunctionCheckCompilerFlags("/wd4316" MITK_CXX_FLAGS) # warning C4316: object alignment on heap
 endif()
 
 if(NOT MSVC_VERSION)
   foreach(_flag
     -Wall
     -Wextra
     -Wpointer-arith
     -Winvalid-pch
     -Wcast-align
     -Wwrite-strings
     -Wno-error=gnu
     -Wno-error=unknown-pragmas
     # The strict-overflow warning is generated by ITK template code
     -Wno-error=strict-overflow
     -Woverloaded-virtual
     -Wstrict-null-sentinel
     #-Wold-style-cast
     #-Wsign-promo
 
     # the following two lines should be removed after ITK-3097 has
     # been resolved, see also MITK bug 15279
     -Wno-unused-local-typedefs
     -Wno-array-bounds
 
     -fdiagnostics-show-option
     )
     mitkFunctionCheckCAndCXXCompilerFlags(${_flag} MITK_C_FLAGS MITK_CXX_FLAGS)
   endforeach()
 endif()
 
 if(CMAKE_COMPILER_IS_GNUCXX AND NOT APPLE)
   mitkFunctionCheckCompilerFlags("-Wl,--no-undefined" MITK_SHARED_LINKER_FLAGS)
   mitkFunctionCheckCompilerFlags("-Wl,--as-needed" MITK_SHARED_LINKER_FLAGS)
 endif()
 
 if(CMAKE_COMPILER_IS_GNUCXX)
-
-  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"))
     mitkFunctionCheckCAndCXXCompilerFlags("-fstack-protector-all" MITK_C_FLAGS MITK_CXX_FLAGS)
   endif()
   if(MINGW)
     # suppress warnings about auto imported symbols
     set(MITK_SHARED_LINKER_FLAGS "-Wl,--enable-auto-import ${MITK_SHARED_LINKER_FLAGS}")
   endif()
 
   set(MITK_CXX_FLAGS_RELEASE "-D_FORTIFY_SOURCE=2 ${MITK_CXX_FLAGS_RELEASE}")
-
 endif()
 
 set(MITK_MODULE_LINKER_FLAGS ${MITK_SHARED_LINKER_FLAGS})
 set(MITK_EXE_LINKER_FLAGS ${MITK_SHARED_LINKER_FLAGS})
 
 #-----------------------------------------------------------------------------
 # MITK Packages
 #-----------------------------------------------------------------------------
 
 set(MITK_MODULES_PACKAGE_DEPENDS_DIR ${MITK_SOURCE_DIR}/CMake/PackageDepends)
 set(MODULES_PACKAGE_DEPENDS_DIRS ${MITK_MODULES_PACKAGE_DEPENDS_DIR})
 
 # This property is populated at the top half of this file
 get_property(MITK_EXTERNAL_PROJECTS GLOBAL PROPERTY MITK_EXTERNAL_PROJECTS)
 foreach(ep ${MITK_EXTERNAL_PROJECTS})
   get_property(_package GLOBAL PROPERTY MITK_${ep}_PACKAGE)
   get_property(_components GLOBAL PROPERTY MITK_${ep}_COMPONENTS)
   if(MITK_USE_${ep} AND _package)
     if(_components)
       find_package(${_package} COMPONENTS ${_components} REQUIRED CONFIG)
     else()
       # Prefer config mode first because it finds external
       # <proj>Config.cmake files pointed at by <proj>_DIR variables.
       # Otherwise, existing Find<proj>.cmake files could file
       # (e.g. in the case of GLEW and the FindGLEW.cmake file shipped
       # with CMake).
       find_package(${_package} QUIET CONFIG)
       string(TOUPPER "${_package}" _package_uc)
       if(NOT (${_package}_FOUND OR ${_package_uc}_FOUND))
         find_package(${_package} REQUIRED)
       endif()
     endif()
   endif()
 endforeach()
 
 if(MITK_USE_Python)
   find_package(PythonLibs REQUIRED)
   find_package(PythonInterp REQUIRED)
 endif()
 
 if(MITK_USE_SOFA)
   # The SOFAConfig.cmake file does not provide exported targets or
   # libraries with absolute paths, hence we need to make the link
   # directories globally available until the SOFAConfig.cmake file
   # supports a proper mechanism for handling targets.
   # The same code is needed in MITKConfig.cmake.
   link_directories(${SOFA_LIBRARY_DIRS})
 endif()
 
 if(MITK_USE_Boost)
   # Same as SOFA above
   link_directories(${Boost_LIBRARY_DIRS})
 endif()
 
 if(MITK_USE_OpenIGTLink)
   # Same as SOFA above
   link_directories(${OpenIGTLink_LIBRARY_DIRS})
 endif()
 
 # Qt support
 if(MITK_USE_QT)
   if(DESIRED_QT_VERSION MATCHES 4)
     find_package(Qt4 ${MITK_QT4_MINIMUM_VERSION} REQUIRED)
   elseif(DESIRED_QT_VERSION MATCHES 5)
     find_package(Qt5Core ${MITK_QT5_MINIMUM_VERSION} REQUIRED) # at least Core required
+    get_target_property(_qmake_exec Qt5::qmake LOCATION)
+    execute_process(COMMAND ${_qmake_exec} -query QT_INSTALL_BINS
+      RESULT_VARIABLE _result
+      OUTPUT_VARIABLE QT_BINARY_DIR
+      ERROR_VARIABLE _error
+    )
+    string(STRIP "${QT_BINARY_DIR}" QT_BINARY_DIR)
+    if(_result OR NOT EXISTS "${QT_BINARY_DIR}")
+      message(FATAL_ERROR "Could not determine Qt binary directory: ${_result} ${QT_BINARY_DIR} ${_error}")
+    endif()
   endif()
 endif()
 
 # Ensure that the MITK CMake module path comes first
 set(CMAKE_MODULE_PATH
   ${MITK_CMAKE_DIR}
   ${CMAKE_MODULE_PATH}
   )
 
 #-----------------------------------------------------------------------------
 # Testing
 #-----------------------------------------------------------------------------
 
 if(BUILD_TESTING)
   enable_testing()
   include(CTest)
   mark_as_advanced(TCL_TCLSH DART_ROOT)
 
   option(MITK_ENABLE_RENDERING_TESTING OFF "Enable the MITK rendering tests. Requires x-server in Linux.")
   #Rendering testing does not work for Linux nightlies, thus it is disabled per default
   #and activated for Mac and Windows.
   if(WIN32 OR APPLE)
     set(MITK_ENABLE_RENDERING_TESTING ON)
   endif()
   mark_as_advanced( MITK_ENABLE_RENDERING_TESTING )
 
   # 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()
 
   # Test the external project template
   if(MITK_USE_BLUEBERRY)
     #include(mitkTestProjectTemplate)
   endif()
 
   # Test the package target
   include(mitkPackageTest)
 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()
 
 #-----------------------------------------------------------------------------
 # Set C/CXX and linker flags for MITK code
 #-----------------------------------------------------------------------------
 
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${MITK_CXX_FLAGS}")
 set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} ${MITK_CXX_FLAGS_DEBUG}")
 set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} ${MITK_CXX_FLAGS_RELEASE}")
 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${MITK_C_FLAGS}")
 set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} ${MITK_C_FLAGS_DEBUG}")
 set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} ${MITK_C_FLAGS_RELEASE}")
 
 set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${MITK_EXE_LINKER_FLAGS}")
 set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} ${MITK_SHARED_LINKER_FLAGS}")
 set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} ${MITK_MODULE_LINKER_FLAGS}")
 
 #-----------------------------------------------------------------------------
 # Compile Utilities and set-up MITK variables
 #-----------------------------------------------------------------------------
 
 add_subdirectory(Utilities)
 
 if(MITK_USE_BLUEBERRY)
 
   # We need to hack a little bit because MITK applications may need
   # to enable certain BlueBerry plug-ins. However, these plug-ins
   # are validated separately from the MITK plug-ins and know nothing
   # about potential MITK plug-in dependencies of the applications. Hence
   # we cannot pass the MITK application list to the BlueBerry
   # ctkMacroSetupPlugins call but need to extract the BlueBerry dependencies
   # from the applications and set them explicitly.
 
   include("${CMAKE_CURRENT_SOURCE_DIR}/Applications/AppList.cmake")
 
   foreach(mitk_app ${MITK_APPS})
     # extract target_dir and option_name
     string(REPLACE "^^" "\\;" target_info ${mitk_app})
     set(target_info_list ${target_info})
     list(GET target_info_list 0 target_dir)
     list(GET target_info_list 1 option_name)
     # check if the application is enabled and if target_libraries.cmake exists
     if((${option_name} OR MITK_BUILD_ALL_APPS) AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/Applications/${target_dir}/target_libraries.cmake")
       include("${CMAKE_CURRENT_SOURCE_DIR}/Applications/${target_dir}/target_libraries.cmake")
       foreach(_target_dep ${target_libraries})
         if(_target_dep MATCHES org_blueberry_)
           string(REPLACE _ . _app_bb_dep ${_target_dep})
           # explicitly set the build option for the BlueBerry plug-in
           set(BLUEBERRY_BUILD_${_app_bb_dep} ON CACHE BOOL "Build the ${_app_bb_dep} plug-in")
         endif()
       endforeach()
     endif()
   endforeach()
 
   set(mbilog_DIR "${mbilog_BINARY_DIR}")
 
   if(MITK_BUILD_ALL_PLUGINS)
     set(BLUEBERRY_BUILD_ALL_PLUGINS ON)
   endif()
 
   set(BLUEBERRY_XPDOC_OUTPUT_DIR ${MITK_DOXYGEN_OUTPUT_DIR}/html/extension-points/html/)
 
   add_subdirectory(BlueBerry)
 
   set(BlueBerry_DIR ${CMAKE_CURRENT_BINARY_DIR}/BlueBerry
       CACHE PATH "The directory containing a CMake configuration file for BlueBerry" FORCE)
 
   include(mitkMacroCreateCTKPlugin)
 
 endif()
 
 #-----------------------------------------------------------------------------
 # Add custom targets representing CDash subprojects
 #-----------------------------------------------------------------------------
 
 foreach(subproject ${CTEST_PROJECT_SUBPROJECTS})
   if(NOT TARGET ${subproject} AND NOT subproject MATCHES "Unlabeled")
     add_custom_target(${subproject})
   endif()
 endforeach()
 
 #-----------------------------------------------------------------------------
 # Add subdirectories
 #-----------------------------------------------------------------------------
 
 add_subdirectory(Modules)
 
 if(MITK_USE_BLUEBERRY)
 
   find_package(BlueBerry REQUIRED)
 
   set(MITK_DEFAULT_SUBPROJECTS MITK-Plugins)
 
   # Plug-in testing (needs some work to be enabled again)
   if(BUILD_TESTING)
     include(berryTestingHelpers)
 
     set(BLUEBERRY_UI_TEST_APP "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/CoreApp")
     if(TARGET CoreApp)
       get_target_property(_is_macosx_bundle CoreApp MACOSX_BUNDLE)
       if(APPLE AND _is_macosx_bundle)
         set(BLUEBERRY_UI_TEST_APP "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/CoreApp.app/Contents/MacOS/CoreApp")
       endif()
     endif()
     set(BLUEBERRY_TEST_APP_ID "org.mitk.qt.coreapplication")
   endif()
 
   include("${CMAKE_CURRENT_SOURCE_DIR}/Plugins/PluginList.cmake")
   mitkFunctionWhitelistPlugins(MITK MITK_EXT_PLUGINS)
 
   set(mitk_plugins_fullpath "")
   foreach(mitk_plugin ${MITK_EXT_PLUGINS})
     list(APPEND mitk_plugins_fullpath Plugins/${mitk_plugin})
   endforeach()
 
   if(EXISTS ${MITK_PRIVATE_MODULES}/PluginList.cmake)
     include(${MITK_PRIVATE_MODULES}/PluginList.cmake)
 
     foreach(mitk_plugin ${MITK_PRIVATE_PLUGINS})
       list(APPEND mitk_plugins_fullpath ${MITK_PRIVATE_MODULES}/${mitk_plugin})
     endforeach()
   endif()
 
   if(MITK_BUILD_EXAMPLES)
     include("${CMAKE_CURRENT_SOURCE_DIR}/Examples/Plugins/PluginList.cmake")
     set(mitk_example_plugins_fullpath )
     foreach(mitk_example_plugin ${MITK_EXAMPLE_PLUGINS})
       list(APPEND mitk_example_plugins_fullpath Examples/Plugins/${mitk_example_plugin})
       list(APPEND mitk_plugins_fullpath Examples/Plugins/${mitk_example_plugin})
     endforeach()
   endif()
 
   # Specify which plug-ins belong to this project
   macro(GetMyTargetLibraries all_target_libraries varname)
     set(re_ctkplugin_mitk "^org_mitk_[a-zA-Z0-9_]+$")
     set(re_ctkplugin_bb "^org_blueberry_[a-zA-Z0-9_]+$")
     set(_tmp_list)
     list(APPEND _tmp_list ${all_target_libraries})
     ctkMacroListFilter(_tmp_list re_ctkplugin_mitk re_ctkplugin_bb OUTPUT_VARIABLE ${varname})
   endmacro()
 
   # Get infos about application directories and build options
   include("${CMAKE_CURRENT_SOURCE_DIR}/Applications/AppList.cmake")
   set(mitk_apps_fullpath )
   foreach(mitk_app ${MITK_APPS})
     string(FIND ${mitk_app} "MITK_BUILD_APP_" _index)
     string(SUBSTRING ${mitk_app} ${_index} -1 _var)
     if(${_var})
       list(APPEND mitk_apps_fullpath "${CMAKE_CURRENT_SOURCE_DIR}/Applications/${mitk_app}")
     endif()
   endforeach()
 
   if (mitk_plugins_fullpath)
     ctkMacroSetupPlugins(${mitk_plugins_fullpath}
                          BUILD_OPTION_PREFIX MITK_BUILD_
                          APPS ${mitk_apps_fullpath}
                          BUILD_ALL ${MITK_BUILD_ALL_PLUGINS}
                          COMPACT_OPTIONS)
   endif()
 
   set(MITK_PLUGIN_USE_FILE "${MITK_BINARY_DIR}/MitkPluginUseFile.cmake")
   if(${PROJECT_NAME}_PLUGIN_LIBRARIES)
     ctkFunctionGeneratePluginUseFile(${MITK_PLUGIN_USE_FILE})
   else()
     file(REMOVE ${MITK_PLUGIN_USE_FILE})
     set(MITK_PLUGIN_USE_FILE )
   endif()
 endif()
 
 #-----------------------------------------------------------------------------
 # Documentation
 #-----------------------------------------------------------------------------
 
 add_subdirectory(Documentation)
 
 #-----------------------------------------------------------------------------
 # Installation
 #-----------------------------------------------------------------------------
 
 
 # set MITK cpack variables
 # These are the default variables, which can be overwritten ( see below )
 include(mitkSetupCPack)
 
 set(use_default_config ON)
 
 # MITK_APPS is set in Applications/AppList.cmake (included somewhere above
 # if MITK_USE_BLUEBERRY is set to ON).
 if(MITK_APPS)
 
   set(activated_apps_no 0)
   list(LENGTH MITK_APPS app_count)
 
   # Check how many apps have been enabled
   # If more than one app has been activated, the we use the
   # default CPack configuration. Otherwise that apps configuration
   # will be used, if present.
   foreach(mitk_app ${MITK_APPS})
     # extract option_name
     string(REPLACE "^^" "\\;" target_info ${mitk_app})
     set(target_info_list ${target_info})
     list(GET target_info_list 1 option_name)
     # check if the application is enabled
     if(${option_name} OR MITK_BUILD_ALL_APPS)
       MATH(EXPR activated_apps_no "${activated_apps_no} + 1")
     endif()
   endforeach()
 
   if(app_count EQUAL 1 AND (activated_apps_no EQUAL 1 OR MITK_BUILD_ALL_APPS))
     # Corner case if there is only one app in total
     set(use_project_cpack ON)
   elseif(activated_apps_no EQUAL 1 AND NOT MITK_BUILD_ALL_APPS)
     # Only one app is enabled (no "build all" flag set)
     set(use_project_cpack ON)
   else()
     # Less or more then one app is enabled
     set(use_project_cpack OFF)
   endif()
 
   foreach(mitk_app ${MITK_APPS})
     # extract target_dir and option_name
     string(REPLACE "^^" "\\;" target_info ${mitk_app})
     set(target_info_list ${target_info})
     list(GET target_info_list 0 target_dir)
     list(GET target_info_list 1 option_name)
     # check if the application is enabled
     if(${option_name} OR MITK_BUILD_ALL_APPS)
       # check whether application specific configuration files will be used
       if(use_project_cpack)
         # use files if they exist
         if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/Applications/${target_dir}/CPackOptions.cmake")
           include("${CMAKE_CURRENT_SOURCE_DIR}/Applications/${target_dir}/CPackOptions.cmake")
         endif()
 
         if(EXISTS "${PROJECT_SOURCE_DIR}/Applications/${target_dir}/CPackConfig.cmake.in")
           set(CPACK_PROJECT_CONFIG_FILE "${PROJECT_BINARY_DIR}/Applications/${target_dir}/CPackConfig.cmake")
           configure_file(${PROJECT_SOURCE_DIR}/Applications/${target_dir}/CPackConfig.cmake.in
                          ${CPACK_PROJECT_CONFIG_FILE} @ONLY)
           set(use_default_config OFF)
         endif()
       endif()
     # add link to the list
     list(APPEND CPACK_CREATE_DESKTOP_LINKS "${target_dir}")
     endif()
   endforeach()
 
 endif()
 
 # if no application specific configuration file was used, use default
 if(use_default_config)
   configure_file(${MITK_SOURCE_DIR}/MITKCPackOptions.cmake.in
                  ${MITK_BINARY_DIR}/MITKCPackOptions.cmake @ONLY)
   set(CPACK_PROJECT_CONFIG_FILE "${MITK_BINARY_DIR}/MITKCPackOptions.cmake")
 endif()
 
 # include CPack model once all variables are set
 include(CPack)
 
 # Additional installation rules
 include(mitkInstallRules)
 
 #-----------------------------------------------------------------------------
 # Last configuration steps
 #-----------------------------------------------------------------------------
 
 # ---------------- Export targets -----------------
 
 set(MITK_EXPORTS_FILE "${MITK_BINARY_DIR}/MitkExports.cmake")
 file(REMOVE ${MITK_EXPORTS_FILE})
 
 set(targets_to_export)
 get_property(module_targets GLOBAL PROPERTY MITK_MODULE_TARGETS)
 if(module_targets)
   list(APPEND targets_to_export ${module_targets})
 endif()
 
 if(MITK_USE_BLUEBERRY)
   if(MITK_PLUGIN_LIBRARIES)
     list(APPEND targets_to_export ${MITK_PLUGIN_LIBRARIES})
   endif()
 endif()
 
 export(TARGETS ${targets_to_export} APPEND
        FILE ${MITK_EXPORTS_FILE})
 
 set(MITK_EXPORTED_TARGET_PROPERTIES )
 foreach(target_to_export ${targets_to_export})
   get_target_property(autoload_targets ${target_to_export} MITK_AUTOLOAD_TARGETS)
   if(autoload_targets)
     set(MITK_EXPORTED_TARGET_PROPERTIES "${MITK_EXPORTED_TARGET_PROPERTIES}
 set_target_properties(${target_to_export} PROPERTIES MITK_AUTOLOAD_TARGETS \"${autoload_targets}\")")
   endif()
   get_target_property(autoload_dir ${target_to_export} MITK_AUTOLOAD_DIRECTORY)
   if(autoload_dir)
     set(MITK_EXPORTED_TARGET_PROPERTIES "${MITK_EXPORTED_TARGET_PROPERTIES}
 set_target_properties(${target_to_export} PROPERTIES MITK_AUTOLOAD_DIRECTORY \"${autoload_dir}\")")
   endif()
 
   get_target_property(deprecated_module ${target_to_export} MITK_MODULE_DEPRECATED_SINCE)
   if(deprecated_module)
     set(MITK_EXPORTED_TARGET_PROPERTIES "${MITK_EXPORTED_TARGET_PROPERTIES}
 set_target_properties(${target_to_export} PROPERTIES MITK_MODULE_DEPRECATED_SINCE \"${deprecated_module}\")")
   endif()
 endforeach()
 
 # ---------------- External projects -----------------
 
 get_property(MITK_ADDITIONAL_LIBRARY_SEARCH_PATHS_CONFIG GLOBAL PROPERTY MITK_ADDITIONAL_LIBRARY_SEARCH_PATHS)
 
 set(MITK_CONFIG_EXTERNAL_PROJECTS )
 #string(REPLACE "^^" ";" _mitk_external_projects ${MITK_EXTERNAL_PROJECTS})
 
 foreach(ep ${MITK_EXTERNAL_PROJECTS})
   get_property(_components GLOBAL PROPERTY MITK_${ep}_COMPONENTS)
   set(MITK_CONFIG_EXTERNAL_PROJECTS "${MITK_CONFIG_EXTERNAL_PROJECTS}
 set(MITK_USE_${ep} ${MITK_USE_${ep}})
 set(MITK_${ep}_DIR \"${${ep}_DIR}\")
 set(MITK_${ep}_COMPONENTS ${_components})
 ")
 endforeach()
 
 foreach(ep ${MITK_EXTERNAL_PROJECTS})
   get_property(_package GLOBAL PROPERTY MITK_${ep}_PACKAGE)
   get_property(_components GLOBAL PROPERTY MITK_${ep}_COMPONENTS)
   if(_components)
       set(_components_arg COMPONENTS \${_components})
   else()
     set(_components_arg)
   endif()
 
   if(_package)
     set(MITK_CONFIG_EXTERNAL_PROJECTS "${MITK_CONFIG_EXTERNAL_PROJECTS}
 if(MITK_USE_${ep})
   set(${ep}_DIR \${MITK_${ep}_DIR})
   if(MITK_${ep}_COMPONENTS)
     mitkMacroFindDependency(${_package} COMPONENTS \${MITK_${ep}_COMPONENTS})
   else()
     mitkMacroFindDependency(${_package})
   endif()
 endif()")
   endif()
 endforeach()
 
 
 # ---------------- Tools -----------------
 
 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 files -----------------
 
 configure_file(mitkVersion.h.in ${MITK_BINARY_DIR}/mitkVersion.h)
 configure_file(mitkConfig.h.in ${MITK_BINARY_DIR}/mitkConfig.h)
 
 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)
 
 write_basic_config_version_file(${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake
   VERSION ${MITK_VERSION_STRING} COMPATIBILITY AnyNewerVersion)
 
 # If we are under Windows, create two batch files which correctly
 # set up the environment for the application and for Visual Studio
 if(WIN32)
   include(mitkFunctionCreateWindowsBatchScript)
 
   set(VS_SOLUTION_FILE "${PROJECT_BINARY_DIR}/${PROJECT_NAME}.sln")
   foreach(VS_BUILD_TYPE debug release)
     mitkFunctionCreateWindowsBatchScript("${MITK_SOURCE_DIR}/CMake/StartVS.bat.in"
       ${PROJECT_BINARY_DIR}/StartVS_${VS_BUILD_TYPE}.bat
       ${VS_BUILD_TYPE})
   endforeach()
 endif(WIN32)
 
 
 #-----------------------------------------------------------------------------
 # MITK Applications
 #-----------------------------------------------------------------------------
 
 # This must come after MITKConfig.h was generated, since applications
 # might do a find_package(MITK REQUIRED).
 add_subdirectory(Applications)
 
 #-----------------------------------------------------------------------------
 # MITK Examples
 #-----------------------------------------------------------------------------
 
 if(MITK_BUILD_EXAMPLES)
   # This must come after MITKConfig.h was generated, since applications
   # might do a find_package(MITK REQUIRED).
   add_subdirectory(Examples)
 endif()
 
 #-----------------------------------------------------------------------------
 # Print configuration summary
 #-----------------------------------------------------------------------------
 
 message("\n\n")
 feature_summary(
   DESCRIPTION "------- FEATURE SUMMARY FOR ${PROJECT_NAME} -------"
   WHAT ALL
 )
 
diff --git a/Modules/CppMicroServices/core/src/util/usListenerFunctors_p.h b/Modules/CppMicroServices/core/src/util/usListenerFunctors_p.h
index 4a009007a7..199141064f 100644
--- a/Modules/CppMicroServices/core/src/util/usListenerFunctors_p.h
+++ b/Modules/CppMicroServices/core/src/util/usListenerFunctors_p.h
@@ -1,85 +1,89 @@
 /*=============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center,
     Division of Medical and Biological Informatics
 
   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at
 
     http://www.apache.org/licenses/LICENSE-2.0
 
   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
 
 =============================================================================*/
 
 #ifndef USLISTENERFUNCTORS_P_H
 #define USLISTENERFUNCTORS_P_H
 
 #include <usServiceEvent.h>
 #include <usModuleEvent.h>
 
 #include <algorithm>
 #include <cstring>
 
-#ifdef US_HAVE_FUNCTIONAL_H
-  #include <functional>
-#elif defined(US_HAVE_TR1_FUNCTIONAL_H)
-  #include <tr1/functional>
-#endif
-
 #ifdef US_HAVE_STD_FUNCTION
+  #ifdef US_HAVE_FUNCTIONAL_H
+    #include <functional>
+  #elif defined(US_HAVE_TR1_FUNCTIONAL_H)
+    #include <tr1/functional>
+  #endif
   #define US_FUNCTION_TYPE std::function
 #elif defined(US_HAVE_TR1_FUNCTION)
+  #ifdef US_HAVE_TR1_FUNCTIONAL_H
+    #include <tr1/functional>
+  #elif defined(US_HAVE_FUNCTIONAL_H)
+    #include <functional>
+  #endif
   #define US_FUNCTION_TYPE std::tr1::function
 #endif
 
 #define US_MODULE_LISTENER_FUNCTOR US_FUNCTION_TYPE<void(const US_PREPEND_NAMESPACE(ModuleEvent)&)>
 #define US_SERVICE_LISTENER_FUNCTOR US_FUNCTION_TYPE<void(const US_PREPEND_NAMESPACE(ServiceEvent)&)>
 
 US_BEGIN_NAMESPACE
   template<class X>
   US_MODULE_LISTENER_FUNCTOR ModuleListenerMemberFunctor(X* x, void (X::*memFn)(const US_PREPEND_NAMESPACE(ModuleEvent)))
   { return std::bind1st(std::mem_fun(memFn), x); }
 
   struct ModuleListenerCompare : std::binary_function<std::pair<US_MODULE_LISTENER_FUNCTOR, void*>,
                                                       std::pair<US_MODULE_LISTENER_FUNCTOR, void*>, bool>
   {
     bool operator()(const std::pair<US_MODULE_LISTENER_FUNCTOR, void*>& p1,
                     const std::pair<US_MODULE_LISTENER_FUNCTOR, void*>& p2) const
     {
       return p1.second == p2.second &&
              p1.first.target<void(const US_PREPEND_NAMESPACE(ModuleEvent)&)>() == p2.first.target<void(const US_PREPEND_NAMESPACE(ModuleEvent)&)>();
     }
   };
 
   template<class X>
   US_SERVICE_LISTENER_FUNCTOR ServiceListenerMemberFunctor(X* x, void (X::*memFn)(const US_PREPEND_NAMESPACE(ServiceEvent)))
   { return std::bind1st(std::mem_fun(memFn), x); }
 
   struct ServiceListenerCompare : std::binary_function<US_SERVICE_LISTENER_FUNCTOR, US_SERVICE_LISTENER_FUNCTOR, bool>
   {
     bool operator()(const US_SERVICE_LISTENER_FUNCTOR& f1,
                     const US_SERVICE_LISTENER_FUNCTOR& f2) const
     {
       return f1.target<void(const US_PREPEND_NAMESPACE(ServiceEvent)&)>() == f2.target<void(const US_PREPEND_NAMESPACE(ServiceEvent)&)>();
     }
   };
 US_END_NAMESPACE
 
 US_HASH_FUNCTION_NAMESPACE_BEGIN
 US_HASH_FUNCTION_BEGIN(US_SERVICE_LISTENER_FUNCTOR)
   void(*targetFunc)(const US_PREPEND_NAMESPACE(ServiceEvent)&) = arg.target<void(const US_PREPEND_NAMESPACE(ServiceEvent)&)>();
   void* targetPtr = NULL;
   std::memcpy(&targetPtr, &targetFunc, sizeof(void*));
   return US_HASH_FUNCTION(void*, targetPtr);
 US_HASH_FUNCTION_END
 US_HASH_FUNCTION_NAMESPACE_END
 
 #endif // USLISTENERFUNCTORS_P_H
diff --git a/Modules/OpenCL/CMakeLists.txt b/Modules/OpenCL/CMakeLists.txt
index 0c9b624085..25b7ef1cbd 100644
--- a/Modules/OpenCL/CMakeLists.txt
+++ b/Modules/OpenCL/CMakeLists.txt
@@ -1,11 +1,12 @@
 if(MITK_USE_OpenCL)
 
   # create the module
   MITK_CREATE_MODULE(
     DEPENDS MitkCore
-    PACKAGE_DEPENDS OpenCL
-                    ITK|ITKThresholding
+    PACKAGE_DEPENDS
+      PUBLIC OpenCL
+      PRIVATE ITK|ITKThresholding
   )
 
   add_subdirectory(Testing)
 endif(MITK_USE_OpenCL)
diff --git a/SuperBuild.cmake b/SuperBuild.cmake
index cc83b6f696..02b23cf058 100644
--- a/SuperBuild.cmake
+++ b/SuperBuild.cmake
@@ -1,444 +1,439 @@
 include(mitkFunctionInstallExternalCMakeProject)
 include(mitkFunctionCheckCompilerFlags)
 
 #-----------------------------------------------------------------------------
 # Convenient macro allowing to download a file
 #-----------------------------------------------------------------------------
 
 if(NOT MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL)
   set(MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL http://mitk.org/download/thirdparty)
 endif()
 
 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
 #-----------------------------------------------------------------------------
 
 if(UNIX AND NOT APPLE)
 
   include(mitkFunctionCheckPackageHeader)
 
   # Check for libxt-dev
   mitkFunctionCheckPackageHeader(StringDefs.h libxt-dev /usr/include/X11/)
 
   # Check for libtiff4-dev
   mitkFunctionCheckPackageHeader(tiff.h libtiff4-dev)
 
   # Check for libwrap0-dev
   mitkFunctionCheckPackageHeader(tcpd.h libwrap0-dev)
 
 endif()
 
 # We need a proper patch program. On Linux and MacOS, we assume
 # that "patch" is available. On Windows, we download patch.exe
 # if not patch program is found.
 find_program(PATCH_COMMAND patch)
 if((NOT PATCH_COMMAND OR NOT EXISTS ${PATCH_COMMAND}) AND WIN32)
   downloadFile(${MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL}/patch.exe
                ${CMAKE_CURRENT_BINARY_DIR}/patch.exe)
   find_program(PATCH_COMMAND patch ${CMAKE_CURRENT_BINARY_DIR})
 endif()
 if(NOT PATCH_COMMAND)
   message(FATAL_ERROR "No patch program found.")
 endif()
 
 #-----------------------------------------------------------------------------
 # Qt options for external projects and MITK
 #-----------------------------------------------------------------------------
 
 if(MITK_USE_QT)
   set(qt_project_args -DDESIRED_QT_VERSION:STRING=${DESIRED_QT_VERSION})
 else()
   set(qt_project_args )
 endif()
 
 if(MITK_USE_Qt4)
   list(APPEND qt_project_args
        -DQT_QMAKE_EXECUTABLE:FILEPATH=${QT_QMAKE_EXECUTABLE} )
 endif()
 
 #-----------------------------------------------------------------------------
 # ExternalProjects
 #-----------------------------------------------------------------------------
 
 get_property(external_projects GLOBAL PROPERTY MITK_EXTERNAL_PROJECTS)
 
 # A list of "nice" external projects, playing well together with CMake
 set(nice_external_projects ${external_projects})
 list(REMOVE_ITEM nice_external_projects Boost Python)
 foreach(proj ${nice_external_projects})
   if(MITK_USE_${proj})
     set(EXTERNAL_${proj}_DIR "${${proj}_DIR}" CACHE PATH "Path to ${proj} build directory")
     mark_as_advanced(EXTERNAL_${proj}_DIR)
     if(EXTERNAL_${proj}_DIR)
       set(${proj}_DIR ${EXTERNAL_${proj}_DIR})
     endif()
   endif()
 endforeach()
 
 if(MITK_USE_Boost)
   set(EXTERNAL_BOOST_ROOT "${BOOST_ROOT}" CACHE PATH "Path to Boost directory")
   mark_as_advanced(EXTERNAL_BOOST_ROOT)
   if(EXTERNAL_BOOST_ROOT)
     set(BOOST_ROOT ${EXTERNAL_BOOST_ROOT})
   endif()
 endif()
 
 # Setup file for setting custom ctest vars
 configure_file(
   CMake/SuperbuildCTestCustom.cmake.in
   ${MITK_BINARY_DIR}/CTestCustom.cmake
   @ONLY
 )
 
 if(BUILD_TESTING)
   set(EXTERNAL_MITK_DATA_DIR "${MITK_DATA_DIR}" CACHE PATH "Path to the MITK data directory")
   mark_as_advanced(EXTERNAL_MITK_DATA_DIR)
   if(EXTERNAL_MITK_DATA_DIR)
     set(MITK_DATA_DIR ${EXTERNAL_MITK_DATA_DIR})
   endif()
 endif()
 
 # Look for git early on, if needed
 if((BUILD_TESTING AND NOT EXTERNAL_MITK_DATA_DIR) OR
    (MITK_USE_CTK AND NOT EXTERNAL_CTK_DIR))
   find_package(Git REQUIRED)
 endif()
 
 #-----------------------------------------------------------------------------
 # External project settings
 #-----------------------------------------------------------------------------
 
 include(ExternalProject)
 
 set(ep_prefix "${CMAKE_BINARY_DIR}/ep")
 set_property(DIRECTORY PROPERTY EP_PREFIX ${ep_prefix})
 
 # 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(MSVC_VERSION)
   set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /bigobj /MP")
   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /bigobj /MP")
 endif()
 
-# This is necessary to avoid problems with compile feature checks.
-# CMAKE_CXX_STANDARD seems to only set the -std=c++11 flag for targets.
-# The CMAKE_CXX_FLAGS variable is also used for non-CMake based
-# external projects like Boost and PCRE.
-mitkFunctionCheckCompilerFlags("-std=c++11" CMAKE_CXX_FLAGS)
-
 # This is a workaround for passing linker flags
 # actually down to the linker invocation
 set(_cmake_required_flags_orig ${CMAKE_REQUIRED_FLAGS})
 set(CMAKE_REQUIRED_FLAGS "-Wl,-rpath")
 mitkFunctionCheckCompilerFlags(${CMAKE_REQUIRED_FLAGS} _has_rpath_flag)
 set(CMAKE_REQUIRED_FLAGS ${_cmake_required_flags_orig})
 
 set(_install_rpath_linkflag )
 if(_has_rpath_flag)
   if(APPLE)
     set(_install_rpath_linkflag "-Wl,-rpath,@loader_path/../lib")
   else()
     set(_install_rpath_linkflag "-Wl,-rpath='$ORIGIN/../lib'")
   endif()
 endif()
 
 set(_install_rpath)
 if(APPLE)
   set(_install_rpath "@loader_path/../lib")
 elseif(UNIX)
   # this work for libraries as well as executables
   set(_install_rpath "\$ORIGIN/../lib")
 endif()
 
 set(ep_common_args
-  -DCMAKE_CXX_EXTENSIONS:STRING=0
-  -DCMAKE_CXX_STANDARD:STRING=11
+  -DCMAKE_CXX_EXTENSIONS:STRING=${CMAKE_CXX_EXTENSIONS}
+  -DCMAKE_CXX_STANDARD:STRING=${CMAKE_CXX_STANDARD}
+  -DCMAKE_CXX_STANDARD_REQUIRED:BOOL=${CMAKE_CXX_STANDARD_REQUIRED}
   -DCMAKE_DEBUG_POSTFIX:STRING=d
   -DCMAKE_MACOSX_RPATH:BOOL=TRUE
   "-DCMAKE_INSTALL_RPATH:STRING=${_install_rpath}"
   -DBUILD_TESTING:BOOL=OFF
   -DCMAKE_INSTALL_PREFIX:PATH=<INSTALL_DIR>
   "-DCMAKE_PREFIX_PATH:PATH=<INSTALL_DIR>^^${CMAKE_PREFIX_PATH}"
   -DCMAKE_INCLUDE_PATH:PATH=${CMAKE_INCLUDE_PATH}
   -DCMAKE_LIBRARY_PATH:PATH=${CMAKE_LIBRARY_PATH}
   -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=${CMAKE_C_FLAGS}
-  "-DCMAKE_CXX_FLAGS:STRING=${CMAKE_CXX_FLAGS}"
+  "-DCMAKE_CXX_FLAGS:STRING=${CMAKE_CXX_FLAGS} ${MITK_CXX11_FLAG}"
   #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}
   #link flags
   -DCMAKE_EXE_LINKER_FLAGS:STRING=${CMAKE_EXE_LINKER_FLAGS}
   -DCMAKE_SHARED_LINKER_FLAGS:STRING=${CMAKE_SHARED_LINKER_FLAGS}
   -DCMAKE_MODULE_LINKER_FLAGS:STRING=${CMAKE_MODULE_LINKER_FLAGS}
 )
 
 # Pass the CMAKE_OSX variables to external projects
 if(APPLE)
   set(MAC_OSX_ARCHITECTURE_ARGS
         -DCMAKE_OSX_ARCHITECTURES:PATH=${CMAKE_OSX_ARCHITECTURES}
         -DCMAKE_OSX_DEPLOYMENT_TARGET:PATH=${CMAKE_OSX_DEPLOYMENT_TARGET}
         -DCMAKE_OSX_SYSROOT:PATH=${CMAKE_OSX_SYSROOT}
   )
   set(ep_common_args
         ${MAC_OSX_ARCHITECTURE_ARGS}
         ${ep_common_args}
   )
 endif()
 
 set(mitk_superbuild_ep_args)
 set(mitk_depends )
 
 # Include external projects
 include(CMakeExternals/MITKData.cmake)
 foreach(p ${external_projects})
   include(CMakeExternals/${p}.cmake)
 
   list(APPEND mitk_superbuild_ep_args
        -DMITK_USE_${p}:BOOL=${MITK_USE_${p}}
       )
   get_property(_package GLOBAL PROPERTY MITK_${p}_PACKAGE)
   if(_package)
     list(APPEND mitk_superbuild_ep_args -D${p}_DIR:PATH=${${p}_DIR})
   endif()
 
   list(APPEND mitk_depends ${${p}_DEPENDS})
 endforeach()
 
 #-----------------------------------------------------------------------------
 # Set superbuild boolean args
 #-----------------------------------------------------------------------------
 
 set(mitk_cmake_boolean_args
   BUILD_SHARED_LIBS
   WITH_COVERAGE
   BUILD_TESTING
 
   MITK_BUILD_ALL_PLUGINS
   MITK_BUILD_ALL_APPS
   MITK_BUILD_TUTORIAL # Deprecated. Use MITK_BUILD_EXAMPLES instead
   MITK_BUILD_EXAMPLES
 
   MITK_USE_QT
   MITK_USE_SYSTEM_Boost
   MITK_USE_BLUEBERRY
   MITK_USE_OpenCL
 
   MITK_ENABLE_PIC_READER
   )
 
 #-----------------------------------------------------------------------------
 # 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
     ${mitk_depends}
 )
 #-----------------------------------------------------------------------------
 # Additional MITK CXX/C Flags
 #-----------------------------------------------------------------------------
 
 set(MITK_ADDITIONAL_C_FLAGS "" CACHE STRING "Additional C Flags for MITK")
 set(MITK_ADDITIONAL_C_FLAGS_RELEASE "" CACHE STRING "Additional Release C Flags for MITK")
 set(MITK_ADDITIONAL_C_FLAGS_DEBUG "" CACHE STRING "Additional Debug C Flags for MITK")
 mark_as_advanced(MITK_ADDITIONAL_C_FLAGS MITK_ADDITIONAL_C_FLAGS_DEBUG MITK_ADDITIONAL_C_FLAGS_RELEASE)
 
 set(MITK_ADDITIONAL_CXX_FLAGS "" CACHE STRING "Additional CXX Flags for MITK")
 set(MITK_ADDITIONAL_CXX_FLAGS_RELEASE "" CACHE STRING "Additional Release CXX Flags for MITK")
 set(MITK_ADDITIONAL_CXX_FLAGS_DEBUG "" CACHE STRING "Additional Debug CXX Flags for MITK")
 mark_as_advanced(MITK_ADDITIONAL_CXX_FLAGS MITK_ADDITIONAL_CXX_FLAGS_DEBUG MITK_ADDITIONAL_CXX_FLAGS_RELEASE)
 
 set(MITK_ADDITIONAL_EXE_LINKER_FLAGS "" CACHE STRING "Additional exe linker flags for MITK")
 set(MITK_ADDITIONAL_SHARED_LINKER_FLAGS "" CACHE STRING "Additional shared linker flags for MITK")
 set(MITK_ADDITIONAL_MODULE_LINKER_FLAGS "" CACHE STRING "Additional module linker flags for MITK")
 mark_as_advanced(MITK_ADDITIONAL_EXE_LINKER_FLAGS MITK_ADDITIONAL_SHARED_LINKER_FLAGS MITK_ADDITIONAL_MODULE_LINKER_FLAGS)
 
 #-----------------------------------------------------------------------------
 # MITK Configure
 #-----------------------------------------------------------------------------
 
 if(MITK_INITIAL_CACHE_FILE)
   set(mitk_initial_cache_arg -C "${MITK_INITIAL_CACHE_FILE}")
 endif()
 
 set(mitk_optional_cache_args )
 foreach(type RUNTIME ARCHIVE LIBRARY)
   if(DEFINED CTK_PLUGIN_${type}_OUTPUT_DIRECTORY)
     list(APPEND mitk_optional_cache_args -DCTK_PLUGIN_${type}_OUTPUT_DIRECTORY:PATH=${CTK_PLUGIN_${type}_OUTPUT_DIRECTORY})
   endif()
 endforeach()
 
 # Optional python variables
 if(MITK_USE_Python)
   list(APPEND mitk_optional_cache_args
        -DMITK_USE_Python:BOOL=${MITK_USE_Python}
        -DPYTHON_EXECUTABLE:FILEPATH=${PYTHON_EXECUTABLE}
        -DPYTHON_INCLUDE_DIR:PATH=${PYTHON_INCLUDE_DIR}
        -DPYTHON_LIBRARY:FILEPATH=${PYTHON_LIBRARY}
        -DPYTHON_INCLUDE_DIR2:PATH=${PYTHON_INCLUDE_DIR2}
        -DMITK_USE_SYSTEM_PYTHON:BOOL=${MITK_USE_SYSTEM_PYTHON}
       )
 endif()
 
 if(MITK_USE_QT)
   if(DESIRED_QT_VERSION MATCHES "5")
     list(APPEND mitk_optional_cache_args
       -DQT5_INSTALL_PREFIX:PATH=${QT5_INSTALL_PREFIX}
     )
   endif()
 endif()
 
 set(proj MITK-Configure)
 
 ExternalProject_Add(${proj}
   LIST_SEPARATOR ${sep}
   DOWNLOAD_COMMAND ""
   CMAKE_GENERATOR ${gen}
   CMAKE_CACHE_ARGS
     # --------------- Build options ----------------
     -DCMAKE_INSTALL_PREFIX:PATH=${CMAKE_INSTALL_PREFIX}
     -DCMAKE_BUILD_TYPE:STRING=${CMAKE_BUILD_TYPE}
     # --------------- Compile options ----------------
     -DCMAKE_C_COMPILER:FILEPATH=${CMAKE_C_COMPILER}
     -DCMAKE_CXX_COMPILER:FILEPATH=${CMAKE_CXX_COMPILER}
     "-DCMAKE_C_FLAGS:STRING=${CMAKE_C_FLAGS} ${MITK_ADDITIONAL_C_FLAGS}"
     "-DCMAKE_CXX_FLAGS:STRING=${CMAKE_CXX_FLAGS} ${MITK_ADDITIONAL_CXX_FLAGS}"
     # debug flags
     "-DCMAKE_CXX_FLAGS_DEBUG:STRING=${CMAKE_CXX_FLAGS_DEBUG} ${MITK_ADDITIONAL_CXX_FLAGS_DEBUG}"
     "-DCMAKE_C_FLAGS_DEBUG:STRING=${CMAKE_C_FLAGS_DEBUG} ${MITK_ADDITIONAL_C_FLAGS_DEBUG}"
     # release flags
     "-DCMAKE_CXX_FLAGS_RELEASE:STRING=${CMAKE_CXX_FLAGS_RELEASE} ${MITK_ADDITIONAL_CXX_FLAGS_RELEASE}"
     "-DCMAKE_C_FLAGS_RELEASE:STRING=${CMAKE_C_FLAGS_RELEASE} ${MITK_ADDITIONAL_C_FLAGS_RELEASE}"
     # relwithdebinfo
     -DCMAKE_CXX_FLAGS_RELWITHDEBINFO:STRING=${CMAKE_CXX_FLAGS_RELWITHDEBINFO}
     -DCMAKE_C_FLAGS_RELWITHDEBINFO:STRING=${CMAKE_C_FLAGS_RELWITHDEBINFO}
     # link flags
     "-DCMAKE_EXE_LINKER_FLAGS:STRING=${CMAKE_EXE_LINKER_FLAGS} ${MITK_ADDITIONAL_EXE_LINKER_FLAGS}"
     "-DCMAKE_SHARED_LINKER_FLAGS:STRING=${CMAKE_SHARED_LINKER_FLAGS} ${MITK_ADDITIONAL_SHARED_LINKER_FLAGS}"
     "-DCMAKE_MODULE_LINKER_FLAGS:STRING=${CMAKE_MODULE_LINKER_FLAGS} ${MITK_ADDITIONAL_MODULE_LINKER_FLAGS}"
     # Output directories
     -DMITK_CMAKE_LIBRARY_OUTPUT_DIRECTORY:PATH=${MITK_CMAKE_LIBRARY_OUTPUT_DIRECTORY}
     -DMITK_CMAKE_RUNTIME_OUTPUT_DIRECTORY:PATH=${MITK_CMAKE_RUNTIME_OUTPUT_DIRECTORY}
     -DMITK_CMAKE_ARCHIVE_OUTPUT_DIRECTORY:PATH=${MITK_CMAKE_ARCHIVE_OUTPUT_DIRECTORY}
     # ------------- Boolean build options --------------
     ${mitk_superbuild_boolean_args}
     ${mitk_optional_cache_args}
     -DMITK_USE_SUPERBUILD:BOOL=OFF
     -DMITK_BUILD_CONFIGURATION:STRING=${MITK_BUILD_CONFIGURATION}
     -DCTEST_USE_LAUNCHERS:BOOL=${CTEST_USE_LAUNCHERS}
     # ----------------- Miscellaneous ---------------
     -DMITK_CTEST_SCRIPT_MODE:STRING=${MITK_CTEST_SCRIPT_MODE}
     -DMITK_SUPERBUILD_BINARY_DIR:PATH=${MITK_BINARY_DIR}
     -DMITK_MODULES_TO_BUILD:INTERNAL=${MITK_MODULES_TO_BUILD}
     -DMITK_WHITELIST:STRING=${MITK_WHITELIST}
     -DMITK_WHITELISTS_EXTERNAL_PATH:STRING=${MITK_WHITELISTS_EXTERNAL_PATH}
     -DMITK_WHITELISTS_INTERNAL_PATH:STRING=${MITK_WHITELISTS_INTERNAL_PATH}
     ${qt_project_args}
     -DMITK_ACCESSBYITK_INTEGRAL_PIXEL_TYPES:STRING=${MITK_ACCESSBYITK_INTEGRAL_PIXEL_TYPES}
     -DMITK_ACCESSBYITK_FLOATING_PIXEL_TYPES:STRING=${MITK_ACCESSBYITK_FLOATING_PIXEL_TYPES}
     -DMITK_ACCESSBYITK_COMPOSITE_PIXEL_TYPES:STRING=${MITK_ACCESSBYITK_COMPOSITE_PIXEL_TYPES}
     -DMITK_ACCESSBYITK_VECTOR_PIXEL_TYPES:STRING=${MITK_ACCESSBYITK_VECTOR_PIXEL_TYPES}
     -DMITK_ACCESSBYITK_DIMENSIONS:STRING=${MITK_ACCESSBYITK_DIMENSIONS}
     # --------------- External project options ---------------
     -DMITK_DATA_DIR:PATH=${MITK_DATA_DIR}
     -DMITK_EXTERNAL_PROJECT_PREFIX:PATH=${ep_prefix}
     -DCppMicroServices_DIR:PATH=${CppMicroServices_DIR}
     -DMITK_KWSTYLE_EXECUTABLE:FILEPATH=${MITK_KWSTYLE_EXECUTABLE}
     -DDCMTK_CMAKE_DEBUG_POSTFIX:STRING=d
     -DBOOST_ROOT:PATH=${BOOST_ROOT}
     -DBOOST_LIBRARYDIR:PATH=${BOOST_LIBRARYDIR}
     -DMITK_USE_Boost_LIBRARIES:STRING=${MITK_USE_Boost_LIBRARIES}
   CMAKE_ARGS
     ${mitk_initial_cache_arg}
     ${MAC_OSX_ARCHITECTURE_ARGS}
     ${mitk_superbuild_ep_args}
     "-DCMAKE_PREFIX_PATH:PATH=${ep_prefix}${sep}${CMAKE_PREFIX_PATH}"
 
   SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}
   BINARY_DIR ${CMAKE_BINARY_DIR}/MITK-build
   BUILD_COMMAND ""
   INSTALL_COMMAND ""
   DEPENDS
     MITK-Utilities
   )
 
 mitkFunctionInstallExternalCMakeProject(${proj})
 
 #-----------------------------------------------------------------------------
 # MITK
 #-----------------------------------------------------------------------------
 
 if(CMAKE_GENERATOR MATCHES ".*Makefiles.*")
   set(mitk_build_cmd "$(MAKE)")
 else()
   set(mitk_build_cmd ${CMAKE_COMMAND} --build ${CMAKE_CURRENT_BINARY_DIR}/MITK-build --config ${CMAKE_CFG_INTDIR})
 endif()
 
 if(NOT DEFINED SUPERBUILD_EXCLUDE_MITKBUILD_TARGET OR NOT SUPERBUILD_EXCLUDE_MITKBUILD_TARGET)
   set(MITKBUILD_TARGET_ALL_OPTION "ALL")
 else()
   set(MITKBUILD_TARGET_ALL_OPTION "")
 endif()
 
 add_custom_target(MITK-build ${MITKBUILD_TARGET_ALL_OPTION}
   COMMAND ${mitk_build_cmd}
   WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/MITK-build
   DEPENDS MITK-Configure
   )
 
 #-----------------------------------------------------------------------------
 # Custom target allowing to drive the build of the MITK project itself
 #-----------------------------------------------------------------------------
 
 add_custom_target(MITK
   COMMAND ${mitk_build_cmd}
   WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/MITK-build
 )