diff --git a/CMakeExternals/ACVD.cmake b/CMakeExternals/ACVD.cmake
index c336b242b4..f011a241ea 100644
--- a/CMakeExternals/ACVD.cmake
+++ b/CMakeExternals/ACVD.cmake
@@ -1,48 +1,49 @@
 #-----------------------------------------------------------------------------
 # ACVD
 #-----------------------------------------------------------------------------
 
 if(MITK_USE_ACVD)
   # Sanity checks
   if(DEFINED ACVD_DIR AND NOT EXISTS ${ACVD_DIR})
     message(FATAL_ERROR "ACVD_DIR variable is defined but corresponds to non-existing directory")
   endif()
 
   set(proj ACVD)
   set(proj_DEPENDENCIES VTK)
   set(ACVD_DEPENDS ${proj})
 
   if(NOT DEFINED ACVD_DIR)
 
     set(additional_args )
     if(CTEST_USE_LAUNCHERS)
       list(APPEND additional_args
         "-DCMAKE_PROJECT_${proj}_INCLUDE:FILEPATH=${CMAKE_ROOT}/Modules/CTestUseLaunchers.cmake"
       )
     endif()
 
     ExternalProject_Add(${proj}
       LIST_SEPARATOR ${sep}
       URL ${MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL}/ACVD-vtk6_3d5ae388-patched.tar.gz
       URL_MD5 a59e658c8309f6a7004705d86d520d12
       CMAKE_GENERATOR ${gen}
+      CMAKE_GENERATOR_PLATFORM ${gen_platform}
       CMAKE_ARGS
         ${ep_common_args}
         ${additional_args}
         -DUSE_MULTITHREADING:BOOL=ON
         -DBUILD_EXAMPLES:BOOL=OFF
         -DVTK_DIR:PATH=${VTK_DIR}
       CMAKE_CACHE_ARGS
         ${ep_common_cache_args}
       CMAKE_CACHE_DEFAULT_ARGS
         ${ep_common_cache_default_args}
       DEPENDS ${proj_DEPENDENCIES}
     )
 
     set(ACVD_DIR ${ep_prefix})
     mitkFunctionInstallExternalCMakeProject(${proj})
 
   else()
     mitkMacroEmptyExternalProject(${proj} "${proj_DEPENDENCIES}")
   endif()
 endif()
diff --git a/CMakeExternals/ANN.cmake b/CMakeExternals/ANN.cmake
index 215d7fd6be..fc9e20ab75 100644
--- a/CMakeExternals/ANN.cmake
+++ b/CMakeExternals/ANN.cmake
@@ -1,52 +1,53 @@
 #-----------------------------------------------------------------------------
 # ANN
 #-----------------------------------------------------------------------------
 
 if(MITK_USE_ANN)
 
   # Sanity checks
   if(DEFINED ANN_DIR AND NOT EXISTS ${ANN_DIR})
     message(FATAL_ERROR "ANN_DIR variable is defined but corresponds to non-existing directory")
   endif()
 
   set(proj ANN)
   set(proj_DEPENDENCIES )
   set(ANN_DEPENDS ${proj})
 
   if(NOT DEFINED ANN_DIR)
 
     set(additional_args )
     if(CTEST_USE_LAUNCHERS)
       list(APPEND additional_args
         "-DCMAKE_PROJECT_${proj}_INCLUDE:FILEPATH=${CMAKE_ROOT}/Modules/CTestUseLaunchers.cmake"
       )
     endif()
 
     set(patch_cmd ${CMAKE_COMMAND} -Dproj:STRING=${proj} -Dproj_target:STRING=ann -P ${CMAKE_CURRENT_LIST_DIR}/GenerateDefaultCMakeBuildSystem.cmake)
 
     ExternalProject_Add(${proj}
        LIST_SEPARATOR ${sep}
        URL ${MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL}/ann_1.1.2.tar.gz
        URL_MD5 7ffaacc7ea79ca39d4958a6378071365
        PATCH_COMMAND ${patch_cmd}
        CMAKE_GENERATOR ${gen}
+       CMAKE_GENERATOR_PLATFORM ${gen_platform}
        CMAKE_ARGS
          ${ep_common_args}
          ${additional_args}
        CMAKE_CACHE_ARGS
          ${ep_common_cache_args}
        CMAKE_CACHE_DEFAULT_ARGS
          ${ep_common_cache_default_args}
        DEPENDS ${proj_DEPENDENCIES}
       )
 
     set(ANN_DIR ${ep_prefix}/lib/cmake/ANN)
     mitkFunctionInstallExternalCMakeProject(${proj})
 
   else()
 
     mitkMacroEmptyExternalProject(${proj} "${proj_DEPENDENCIES}")
 
   endif()
 
 endif()
diff --git a/CMakeExternals/CTK.cmake b/CMakeExternals/CTK.cmake
index c1a3945745..72770f393b 100644
--- a/CMakeExternals/CTK.cmake
+++ b/CMakeExternals/CTK.cmake
@@ -1,103 +1,104 @@
 #-----------------------------------------------------------------------------
 # CTK
 #-----------------------------------------------------------------------------
 
 if(MITK_USE_CTK)
 
   # Sanity checks
   if(DEFINED CTK_DIR AND NOT EXISTS ${CTK_DIR})
     message(FATAL_ERROR "CTK_DIR variable is defined but corresponds to non-existing directory")
   endif()
 
   set(proj CTK)
   set(proj_DEPENDENCIES DCMTK)
   set(CTK_DEPENDS ${proj})
 
   if(NOT DEFINED CTK_DIR)
 
     set(revision_tag fc06bedc) # Revision currently points to commit in https://github.com/kislinsk/CTK.git
 
     set(ctk_optional_cache_args )
     if(MITK_USE_Python)
       list(APPEND ctk_optional_cache_args
            -DCTK_LIB_Scripting/Python/Widgets:BOOL=ON
            -DCTK_ENABLE_Python_Wrapping:BOOL=ON
            -DCTK_APP_ctkSimplePythonShell:BOOL=ON
            -DPYTHON_EXECUTABLE:FILEPATH=${PYTHON_EXECUTABLE}
            -DPYTHON_INCLUDE_DIR:PATH=${PYTHON_INCLUDE_DIR}
            -DPYTHON_INCLUDE_DIR2:PATH=${PYTHON_INCLUDE_DIR2}
            -DPYTHON_LIBRARY:FILEPATH=${PYTHON_LIBRARY}
       )
     else()
       list(APPEND ctk_optional_cache_args
            -DCTK_LIB_Scripting/Python/Widgets:BOOL=OFF
            -DCTK_ENABLE_Python_Wrapping:BOOL=OFF
            -DCTK_APP_ctkSimplePythonShell:BOOL=OFF
       )
     endif()
 
     if(NOT MITK_USE_Python)
       list(APPEND ctk_optional_cache_args
         -DDCMTK_CMAKE_DEBUG_POSTFIX:STRING=d
       )
     endif()
 
     if(CTEST_USE_LAUNCHERS)
       list(APPEND ctk_optional_cache_args
         "-DCMAKE_PROJECT_${proj}_INCLUDE:FILEPATH=${CMAKE_ROOT}/Modules/CTestUseLaunchers.cmake"
       )
     endif()
 
     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()
 
     ExternalProject_Add(${proj}
       LIST_SEPARATOR ${sep}
       URL ${MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL}/CTK_${revision_tag}.tar.gz
       URL_MD5 c500f54dd6d2ce2803d705cbb663d2f2
       # PATCH_COMMAND ${PATCH_COMMAND} -N -p1 -i ${CMAKE_CURRENT_LIST_DIR}/CTK.patch
       UPDATE_COMMAND ""
       INSTALL_COMMAND ""
       CMAKE_GENERATOR ${gen}
+      CMAKE_GENERATOR_PLATFORM ${gen_platform}
       CMAKE_ARGS
         ${ep_common_args}
         ${ctk_optional_cache_args}
         # The CTK PluginFramework cannot cope with
         # a non-empty CMAKE_DEBUG_POSTFIX for the plugin
         # libraries yet.
         -DCMAKE_DEBUG_POSTFIX:STRING=
         -DCTK_QT_VERSION:STRING=5
         -DQt5_DIR=${Qt5_DIR}
         -DGit_EXECUTABLE:FILEPATH=${GIT_EXECUTABLE}
         -DGIT_EXECUTABLE:FILEPATH=${GIT_EXECUTABLE}
         -DCTK_LIB_CommandLineModules/Backend/LocalProcess:BOOL=ON
         -DCTK_LIB_CommandLineModules/Frontend/QtGui:BOOL=ON
         -DCTK_LIB_PluginFramework:BOOL=ON
         -DCTK_LIB_DICOM/Widgets:BOOL=ON
         -DCTK_LIB_XNAT/Core:BOOL=ON
         -DCTK_PLUGIN_org.commontk.eventadmin:BOOL=ON
         -DCTK_PLUGIN_org.commontk.configadmin:BOOL=ON
         -DCTK_USE_GIT_PROTOCOL:BOOL=OFF
         -DDCMTK_DIR:PATH=${DCMTK_DIR}
         -DqRestAPI_URL:STRING=${MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL}/qRestAPI_c5e4c2a7_patched.tar.gz
         -DPythonQt_URL:STRING=${MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL}/PythonQt_e39be131.tar.gz # From https://github.com/kislinsk/PythonQt.git
       CMAKE_CACHE_ARGS
         ${ep_common_cache_args}
       CMAKE_CACHE_DEFAULT_ARGS
         ${ep_common_cache_default_args}
       DEPENDS ${proj_DEPENDENCIES}
      )
 
     ExternalProject_Get_Property(${proj} binary_dir)
     set(CTK_DIR ${binary_dir})
 
   else()
 
     mitkMacroEmptyExternalProject(${proj} "${proj_DEPENDENCIES}")
 
   endif()
 
 endif()
diff --git a/CMakeExternals/CppUnit.cmake b/CMakeExternals/CppUnit.cmake
index fe0561a814..085e5f3597 100644
--- a/CMakeExternals/CppUnit.cmake
+++ b/CMakeExternals/CppUnit.cmake
@@ -1,49 +1,50 @@
 #-----------------------------------------------------------------------------
 # CppUnit
 #-----------------------------------------------------------------------------
 
 # Sanity checks
 if(DEFINED CppUnit_DIR AND NOT EXISTS ${CppUnit_DIR})
   message(FATAL_ERROR "CppUnit_DIR variable is defined but corresponds to non-existing directory")
 endif()
 
 set(proj CppUnit)
 set(proj_DEPENDENCIES )
 set(${proj}_DEPENDS ${proj})
 
 if(NOT DEFINED CppUnit_DIR)
 
   set(additional_args )
   if(CTEST_USE_LAUNCHERS)
     list(APPEND additional_args
       "-DCMAKE_PROJECT_${proj}_INCLUDE:FILEPATH=${CMAKE_ROOT}/Modules/CTestUseLaunchers.cmake"
     )
   endif()
 
   ExternalProject_Add(${proj}
      LIST_SEPARATOR ${sep}
      URL ${MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL}/cppunit-1.12.1.tar.gz
      URL_MD5 bd30e9cf5523cdfc019b94f5e1d7fd19
      PATCH_COMMAND
        ${PATCH_COMMAND} -N -p1 -i ${CMAKE_CURRENT_LIST_DIR}/CppUnit-1.12.1.patch
        COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_LIST_DIR}/${proj}config.h.cmake <SOURCE_DIR>/config/config.h.cmake
        COMMAND ${CMAKE_COMMAND} -Dproj=${proj} -Dproj_target:STRING=cppunit -P ${CMAKE_CURRENT_LIST_DIR}/GenerateDefaultCMakeBuildSystem.cmake
      CMAKE_GENERATOR ${gen}
+     CMAKE_GENERATOR_PLATFORM ${gen_platform}
      CMAKE_ARGS
        ${ep_common_args}
        ${additional_args}
      CMAKE_CACHE_ARGS
        ${ep_common_cache_args}
      CMAKE_CACHE_DEFAULT_ARGS
        ${ep_common_cache_default_args}
      DEPENDS ${proj_DEPENDENCIES}
     )
 
   set(${proj}_DIR ${ep_prefix}/lib/cmake/CppUnit)
   mitkFunctionInstallExternalCMakeProject(${proj})
 
 else()
 
   mitkMacroEmptyExternalProject(${proj} "${proj_DEPENDENCIES}")
 
 endif()
diff --git a/CMakeExternals/DCMQI.cmake b/CMakeExternals/DCMQI.cmake
index b4740c5fb0..40f37f6c39 100644
--- a/CMakeExternals/DCMQI.cmake
+++ b/CMakeExternals/DCMQI.cmake
@@ -1,59 +1,60 @@
 #-----------------------------------------------------------------------------
 # DCMQI
 #-----------------------------------------------------------------------------
 
 if(MITK_USE_DCMQI)
 
   # Sanity checks
   if(DEFINED DCMQI_DIR AND NOT EXISTS ${DCMQI_DIR})
     message(FATAL_ERROR "DCMQI_DIR variable is defined but corresponds to non-existing directory")
   endif()
 
   set(proj DCMQI)
   set(proj_DEPENDENCIES DCMTK ITK)
   set(DCMQI_DEPENDS ${proj})
 
   if(NOT DEFINED DCMQI_DIR)
     set(additional_cmake_args)
 
     if(CTEST_USE_LAUNCHERS)
       list(APPEND additional_cmake_args
       "-DCMAKE_PROJECT_${proj}_INCLUDE:FILEPATH=${CMAKE_ROOT}/Modules/CTestUseLaunchers.cmake"
       )
     endif()
 
     ExternalProject_Add(${proj}
       LIST_SEPARATOR ${sep}
       GIT_REPOSITORY https://github.com/nolden/dcmqi.git
       GIT_TAG d067f81c8a8e43900b91861f771013406868672f
       UPDATE_COMMAND ""
       INSTALL_COMMAND ""
       CMAKE_GENERATOR ${gen}
+      CMAKE_GENERATOR_PLATFORM ${gen_platform}
       CMAKE_ARGS
         ${ep_common_args}
         ${additional_cmake_args}
         #-DCMAKE_INSTALL_PREFIX:PATH=<INSTALL_DIR>
         -DBUILD_SHARED_LIBS:BOOL=ON
         -DDCMQI_BUILD_APPS:BOOL=OFF
         -DDCMTK_DIR:PATH=${DCMTK_DIR}
         -DITK_DIR:PATH=${ITK_DIR}
         -DITK_NO_IO_FACTORY_REGISTER_MANAGER:BOOL=ON
         -DDCMQI_SUPERBUILD:BOOL=OFF
         -DDCMQI_CMAKE_CXX_STANDARD:STRING=14
       CMAKE_CACHE_ARGS
         ${ep_common_cache_args}
       CMAKE_CACHE_DEFAULT_ARGS
         ${ep_common_cache_default_args}
       DEPENDS ${proj_DEPENDENCIES}
     )
 
 
     ExternalProject_Get_Property(${proj} binary_dir)
     set(DCMQI_DIR ${binary_dir})
     #set(${proj}_DIR ${ep_prefix})
     #message(${proj}_DIR: ${${proj}_DIR})
     #mitkFunctionInstallExternalCMakeProject(${proj})
   else()
     mitkMacroEmptyExternalProject(${proj} "${proj_DEPENDENCIES}")
   endif()
 endif()
diff --git a/CMakeExternals/DCMTK.cmake b/CMakeExternals/DCMTK.cmake
index 54a10d3eac..14a615a7b3 100644
--- a/CMakeExternals/DCMTK.cmake
+++ b/CMakeExternals/DCMTK.cmake
@@ -1,62 +1,63 @@
 #-----------------------------------------------------------------------------
 # DCMTK
 #-----------------------------------------------------------------------------
 
 if(MITK_USE_DCMTK)
 
   # Sanity checks
   if(DEFINED DCMTK_DIR AND NOT EXISTS ${DCMTK_DIR})
     message(FATAL_ERROR "DCMTK_DIR variable is defined but corresponds to non-existing directory")
   endif()
 
   set(proj DCMTK)
   set(proj_DEPENDENCIES )
   set(DCMTK_DEPENDS ${proj})
 
   if(NOT DEFINED DCMTK_DIR)
     if(DCMTK_DICOM_ROOT_ID)
       set(DCMTK_CXX_FLAGS "${DCMTK_CXX_FLAGS} -DSITE_UID_ROOT=\\\"${DCMTK_DICOM_ROOT_ID}\\\"")
       set(DCMTK_C_FLAGS "${DCMTK_CXX_FLAGS} -DSITE_UID_ROOT=\\\"${DCMTK_DICOM_ROOT_ID}\\\"")
     endif()
 
     set(additional_args )
     if(CTEST_USE_LAUNCHERS)
       list(APPEND additional_args
         "-DCMAKE_PROJECT_${proj}_INCLUDE:FILEPATH=${CMAKE_ROOT}/Modules/CTestUseLaunchers.cmake"
       )
     endif()
 
     ExternalProject_Add(${proj}
       LIST_SEPARATOR ${sep}
       URL ${MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL}/dcmtk_29f9de10.tar.gz
       URL_MD5 c4b13ef2e694f3b8c50d7181fc959f4a
       CMAKE_GENERATOR ${gen}
+      CMAKE_GENERATOR_PLATFORM ${gen_platform}
       CMAKE_ARGS
          ${ep_common_args}
          ${additional_args}
          "-DCMAKE_CXX_FLAGS:STRING=${CMAKE_CXX_FLAGS} ${DCMTK_CXX_FLAGS}"
          "-DCMAKE_C_FLAGS:STRING=${CMAKE_C_FLAGS} ${DCMTK_C_FLAGS}"
          -DDCMTK_ENABLE_CXX11:BOOL=ON
          -DDCMTK_ENABLE_STL:BOOL=ON
          -DDCMTK_WITH_DOXYGEN:BOOL=OFF
          -DDCMTK_WITH_ZLIB:BOOL=OFF # see bug #9894
          -DDCMTK_WITH_OPENSSL:BOOL=OFF # see bug #9894
          -DDCMTK_WITH_PNG:BOOL=OFF # see bug #9894
          -DDCMTK_WITH_TIFF:BOOL=OFF  # see bug #9894
          -DDCMTK_WITH_XML:BOOL=OFF  # see bug #9894
          -DDCMTK_WITH_ICONV:BOOL=OFF  # see bug #9894
       CMAKE_CACHE_ARGS
         ${ep_common_cache_args}
       CMAKE_CACHE_DEFAULT_ARGS
         ${ep_common_cache_default_args}
       DEPENDS ${proj_DEPENDENCIES}
       )
     set(DCMTK_DIR ${ep_prefix})
     mitkFunctionInstallExternalCMakeProject(${proj})
 
   else()
 
     mitkMacroEmptyExternalProject(${proj} "${proj_DEPENDENCIES}")
 
   endif()
 endif()
diff --git a/CMakeExternals/Eigen.cmake b/CMakeExternals/Eigen.cmake
index 51bed8d519..effd8026f9 100644
--- a/CMakeExternals/Eigen.cmake
+++ b/CMakeExternals/Eigen.cmake
@@ -1,42 +1,44 @@
 #-----------------------------------------------------------------------------
 # Eigen
 #-----------------------------------------------------------------------------
 
 if(MITK_USE_Eigen)
 
   # Sanity checks
   if(DEFINED Eigen_DIR AND NOT EXISTS ${Eigen_DIR})
     message(FATAL_ERROR "Eigen_DIR variable is defined but corresponds to non-existing directory")
   endif()
 
   set(proj Eigen)
   set(proj_DEPENDENCIES )
   set(Eigen_DEPENDS ${proj})
 
   if(NOT DEFINED Eigen_DIR)
 
     ExternalProject_Add(${proj}
       LIST_SEPARATOR ${sep}
       URL ${MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL}/eigen-eigen-07105f7124f9.tar.bz2
       URL_MD5 9e3bfaaab3db18253cfd87ea697b3ab1
       PATCH_COMMAND ${PATCH_COMMAND} -N -p1 -i ${CMAKE_CURRENT_LIST_DIR}/Eigen.patch
+      CMAKE_GENERATOR ${gen}
+      CMAKE_GENERATOR_PLATFORM ${gen_platform}
       CMAKE_ARGS
         ${ep_common_args}
         -DBUILD_TESTING:BOOL=ON
         -DEIGEN_BUILD_PKGCONFIG:BOOL=OFF
       CMAKE_CACHE_ARGS
         ${ep_common_cache_args}
       CMAKE_CACHE_DEFAULT_ARGS
         ${ep_common_cache_default_args}
     )
 
     set(Eigen_DIR ${ep_prefix})
     mitkFunctionInstallExternalCMakeProject(${proj})
 
   else()
 
     mitkMacroEmptyExternalProject(${proj} "${proj_DEPENDENCIES}")
 
   endif()
 
 endif()
diff --git a/CMakeExternals/GDCM.cmake b/CMakeExternals/GDCM.cmake
index 9a0c020637..dbbedac025 100644
--- a/CMakeExternals/GDCM.cmake
+++ b/CMakeExternals/GDCM.cmake
@@ -1,65 +1,66 @@
 #-----------------------------------------------------------------------------
 # GDCM
 #-----------------------------------------------------------------------------
 
 # Sanity checks
 if(DEFINED GDCM_DIR AND NOT EXISTS ${GDCM_DIR})
   message(FATAL_ERROR "GDCM_DIR variable is defined but corresponds to non-existing directory")
 endif()
 
 # Check if an external ITK build tree was specified.
 # If yes, use the GDCM from ITK, otherwise ITK will complain
 if(ITK_DIR)
   find_package(ITK)
   if(ITK_GDCM_DIR)
     set(GDCM_DIR ${ITK_GDCM_DIR})
   endif()
 endif()
 
 
 set(proj GDCM)
 set(proj_DEPENDENCIES )
 set(GDCM_DEPENDS ${proj})
 
 if(NOT DEFINED GDCM_DIR)
 
   set(additional_args )
   if(CTEST_USE_LAUNCHERS)
     list(APPEND additional_args
       "-DCMAKE_PROJECT_${proj}_INCLUDE:FILEPATH=${CMAKE_ROOT}/Modules/CTestUseLaunchers.cmake"
     )
   endif()
 
   # On Mac some assertions fail that prevent reading certain DICOM files. Bug #19995
   if(APPLE)
     list(APPEND additional_args
       "-DCMAKE_CXX_FLAGS_DEBUG:STRING=${CMAKE_CXX_FLAGS_DEBUG} -DNDEBUG"
     )
   endif()
 
   ExternalProject_Add(${proj}
      LIST_SEPARATOR ${sep}
      URL ${MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL}/gdcm-2.6.3.tar.bz2
      URL_MD5 52d398f48e672f1949914f6b3e2d528c
      PATCH_COMMAND ${PATCH_COMMAND} -N -p1 -i ${CMAKE_CURRENT_LIST_DIR}/GDCM.patch
      CMAKE_GENERATOR ${gen}
+     CMAKE_GENERATOR_PLATFORM ${gen_platform}
      CMAKE_ARGS
        ${ep_common_args}
        ${additional_args}
        -DGDCM_BUILD_SHARED_LIBS:BOOL=ON
      CMAKE_CACHE_ARGS
        ${ep_common_cache_args}
      CMAKE_CACHE_DEFAULT_ARGS
        ${ep_common_cache_default_args}
      DEPENDS ${proj_DEPENDENCIES}
     )
   set(GDCM_DIR ${ep_prefix})
   mitkFunctionInstallExternalCMakeProject(${proj})
 
 else()
 
   mitkMacroEmptyExternalProject(${proj} "${proj_DEPENDENCIES}")
 
   find_package(GDCM)
 
 endif()
diff --git a/CMakeExternals/GLUT.cmake b/CMakeExternals/GLUT.cmake
index 1c02eed723..15cf36455c 100644
--- a/CMakeExternals/GLUT.cmake
+++ b/CMakeExternals/GLUT.cmake
@@ -1,60 +1,61 @@
 #-----------------------------------------------------------------------------
 # freeglut
 #-----------------------------------------------------------------------------
 
 if(MITK_USE_GLUT)
   # Sanity checks
   if(DEFINED GLUT_DIR AND NOT EXISTS ${GLUT_DIR})
     message(FATAL_ERROR "GLUT_DIR variable is defined but corresponds to non-existing directory")
   endif()
 
   set(proj GLUT)
   set(proj_DEPENDENCIES )
   set(${proj}_DEPENDS ${proj})
 
   if(NOT DEFINED GLUT_DIR)
 
     if(APPLE)
       find_library(GLUT_LIBRARY GLUT)
       # add_library(GLUT SHARED IMPORTED)
       # set_property(TARGET GLUT PROPERTY IMPORTED_LOCATION ${GLUT_LIBRARY})
       mitkMacroEmptyExternalProject(${proj} "${proj_DEPENDENCIES}")
       get_filename_component(GLUT_DIR ${GLUT_LIBRARY} PATH)
     else()
       set(patch_cmd ${CMAKE_COMMAND} -Dproj:STRING=${proj} -Dproj_target:STRING=freeglut -P ${CMAKE_CURRENT_LIST_DIR}/GenerateDefaultCMakeBuildSystem.cmake)
 
       set(additional_args )
       if(CTEST_USE_LAUNCHERS)
         list(APPEND additional_args
           "-DCMAKE_PROJECT_${proj}_INCLUDE:FILEPATH=${CMAKE_ROOT}/Modules/CTestUseLaunchers.cmake"
         )
       endif()
 
       ExternalProject_Add(${proj}
          LIST_SEPARATOR ${sep}
          URL http://mitk.org/download/thirdparty/freeglut-2.8.1.tar.gz
          URL_MD5 918ffbddcffbac83c218bc52355b6d5a
          PATCH_COMMAND ${patch_cmd}
          CMAKE_GENERATOR ${gen}
+         CMAKE_GENERATOR_PLATFORM ${gen_platform}
          CMAKE_ARGS
            ${ep_common_args}
            ${additional_args}
          CMAKE_CACHE_ARGS
            ${ep_common_cache_args}
          CMAKE_CACHE_DEFAULT_ARGS
            ${ep_common_cache_default_args}
          DEPENDS ${proj_DEPENDENCIES}
         )
 
       set(GLUT_DIR ${ep_prefix})
       mitkFunctionInstallExternalCMakeProject(${proj})
 
     endif()
 
   else()
 
     mitkMacroEmptyExternalProject(${proj} "${proj_DEPENDENCIES}")
 
   endif()
 
 endif()
diff --git a/CMakeExternals/HDF5.cmake b/CMakeExternals/HDF5.cmake
index 1c94385671..b336c0cd5b 100644
--- a/CMakeExternals/HDF5.cmake
+++ b/CMakeExternals/HDF5.cmake
@@ -1,58 +1,59 @@
 #-----------------------------------------------------------------------------
 # HDF5
 #-----------------------------------------------------------------------------
 
 if(MITK_USE_HDF5)
 
   # Sanity checks
   if(DEFINED HDF5_DIR AND NOT EXISTS ${HDF5_DIR})
     message(FATAL_ERROR "HDF5_DIR variable is defined but corresponds to non-existing directory")
   endif()
 
   set(proj HDF5)
   set(proj_DEPENDENCIES )
   set(HDF5_DEPENDS ${proj})
 
   if(NOT DEFINED HDF5_DIR)
 
     set(additional_args )
     if(CTEST_USE_LAUNCHERS)
       list(APPEND additional_args
         "-DCMAKE_PROJECT_${proj}_INCLUDE:FILEPATH=${CMAKE_ROOT}/Modules/CTestUseLaunchers.cmake"
       )
     endif()
 
     # We might build static libs with  -DBUILD_SHARED_LIBS=0 but this conflicts with
     # the in ITK integrated version! So we need to go the way with dynamic libs. Too
     # bad :( This would be fixed by using an external HDF-Installation with ITK/VTK
 
     ExternalProject_Add(${proj}
        URL ${MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL}/hdf5-1.8.17.tar.gz
        URL_MD5 7d572f8f3b798a628b8245af0391a0ca
        CMAKE_GENERATOR ${gen}
+       CMAKE_GENERATOR_PLATFORM ${gen_platform}
        CMAKE_ARGS
          ${ep_common_args}
          ${additional_args}
          -DHDF5_BUILD_HL_LIB:BOOL=ON
          -DHDF5_BUILD_CPP_LIB:BOOL=ON
          -DCMAKE_INSTALL_PREFIX:PATH=<INSTALL_DIR>
        CMAKE_CACHE_ARGS
          ${ep_common_cache_args}
        CMAKE_CACHE_DEFAULT_ARGS
          ${ep_common_cache_default_args}
        DEPENDS ${proj_DEPENDENCIES}
       )
 
     ExternalProject_Get_Property(${proj} install_dir)
     if(WIN32)
       set(HDF5_DIR ${install_dir}/cmake/)
     else()
       set(HDF5_DIR ${install_dir}/share/cmake)
     endif()
 
   else()
 
     mitkMacroEmptyExternalProject(${proj} "${proj_DEPENDENCIES}")
 
   endif()
 endif(MITK_USE_HDF5)
diff --git a/CMakeExternals/ITK.cmake b/CMakeExternals/ITK.cmake
index 62654da969..ec5fa25333 100644
--- a/CMakeExternals/ITK.cmake
+++ b/CMakeExternals/ITK.cmake
@@ -1,75 +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()
 
 if(MITK_USE_HDF5)
   list(APPEND proj_DEPENDENCIES HDF5)
 endif()
 
 set(ITK_DEPENDS ${proj})
 
 if(NOT DEFINED ITK_DIR)
 
   set(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
   # for 4.7, the OpenJPEG is needed by review but the variable must be set
     -DModule_ITKOpenJPEG:BOOL=ON
   )
 
   if(CTEST_USE_LAUNCHERS)
     list(APPEND additional_cmake_args
       "-DCMAKE_PROJECT_${proj}_INCLUDE:FILEPATH=${CMAKE_ROOT}/Modules/CTestUseLaunchers.cmake"
     )
   endif()
 
   ExternalProject_Add(${proj}
      LIST_SEPARATOR ${sep}
      URL ${MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL}/InsightToolkit-4.13.1.tar.xz
      URL_MD5 bc7296e7faccdcb5656a7669d4d875d2
      CMAKE_GENERATOR ${gen}
+     CMAKE_GENERATOR_PLATFORM ${gen_platform}
      CMAKE_ARGS
        ${ep_common_args}
        ${additional_cmake_args}
        -DBUILD_EXAMPLES:BOOL=OFF
        -DITK_USE_SYSTEM_GDCM:BOOL=ON
        -DGDCM_DIR:PATH=${GDCM_DIR}
        -DITK_USE_SYSTEM_HDF5:BOOL=ON
        -DHDF5_DIR:PATH=${HDF5_DIR}
      CMAKE_CACHE_ARGS
        ${ep_common_cache_args}
      CMAKE_CACHE_DEFAULT_ARGS
        ${ep_common_cache_default_args}
      DEPENDS ${proj_DEPENDENCIES}
     )
 
   set(ITK_DIR ${ep_prefix})
   mitkFunctionInstallExternalCMakeProject(${proj})
 
 else()
 
   mitkMacroEmptyExternalProject(${proj} "${proj_DEPENDENCIES}")
 
 endif()
diff --git a/CMakeExternals/MatchPoint.cmake b/CMakeExternals/MatchPoint.cmake
index f23fcf2da2..d8a89251fc 100644
--- a/CMakeExternals/MatchPoint.cmake
+++ b/CMakeExternals/MatchPoint.cmake
@@ -1,64 +1,65 @@
 #-----------------------------------------------------------------------------
 # MatchPoint
 #-----------------------------------------------------------------------------
 if(MITK_USE_MatchPoint)
 
   set(MatchPoint_SOURCE_DIR "" CACHE PATH "Location of the MatchPoint source directory")
   mark_as_advanced(MatchPoint_SOURCE_DIR)
 
   # Sanity checks
   if(DEFINED MatchPoint_DIR AND NOT EXISTS ${MatchPoint_DIR})
     message(FATAL_ERROR "MatchPoint_DIR variable is defined but corresponds to non-existing directory")
   endif()
 
   if(NOT MatchPoint_DIR AND MatchPoint_SOURCE_DIR AND NOT EXISTS ${MatchPoint_SOURCE_DIR})
     message(FATAL_ERROR "MatchPoint_SOURCE_DIR variable is defined but corresponds to non-existing directory")
   endif()
 
   set(proj MatchPoint)
   set(proj_DEPENDENCIES ITK)
 
   set(MatchPoint_DEPENDS ${proj})
 
   if(NOT MatchPoint_DIR)
 
     if(MatchPoint_SOURCE_DIR)
       set(download_step SOURCE_DIR ${MatchPoint_SOURCE_DIR})
     else()
       set(download_step
           URL ${MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL}/MatchPoint_rev_24ef6072.tar.gz
           URL_MD5 b0a0d7d63da5071db8e73dd6e6b4db7c
          )
     endif()
 
     ExternalProject_Add(${proj}
        ${download_step}
        # INSTALL_COMMAND "${CMAKE_COMMAND} -P cmake_install.cmake"
        CMAKE_GENERATOR ${gen}
+       CMAKE_GENERATOR_PLATFORM ${gen_platform}
        CMAKE_ARGS
          ${ep_common_args}
          ${additional_cmake_args}
          -DBUILD_TESTING:BOOL=OFF
          -DITK_DIR:PATH=${ITK_DIR} #/src/ITK-build
          -DMAP_USE_SYSTEM_GDCM:BOOL=ON
          -DMAP_USE_SYSTEM_HDF5:BOOL=ON
          -DMAP_DISABLE_ITK_IO_FACTORY_AUTO_REGISTER:BOOL=ON
          -DMAP_WRAP_Plastimatch:BOOL=ON
          -DGDCM_DIR:PATH=${GDCM_DIR}
          -DHDF5_DIR:PATH=${HDF5_DIR}
        CMAKE_CACHE_ARGS
          ${ep_common_cache_args}
        CMAKE_CACHE_DEFAULT_ARGS
          ${ep_common_cache_default_args}
        DEPENDS ${proj_DEPENDENCIES}
       )
 
     ExternalProject_Get_Property(${proj} binary_dir)
     set(${proj}_DIR ${binary_dir})
     mitkFunctionInstallExternalCMakeProject(${proj})
 
   else()
     mitkMacroEmptyExternalProject(${proj} "${proj_DEPENDENCIES}")
   endif()
 
 endif(MITK_USE_MatchPoint)
diff --git a/CMakeExternals/OpenCV.cmake b/CMakeExternals/OpenCV.cmake
index bbf8c8715f..46d6cbd359 100644
--- a/CMakeExternals/OpenCV.cmake
+++ b/CMakeExternals/OpenCV.cmake
@@ -1,100 +1,101 @@
 #-----------------------------------------------------------------------------
 # OpenCV
 #-----------------------------------------------------------------------------
 
 if(MITK_USE_OpenCV)
 
   # Sanity checks
   if(DEFINED OpenCV_DIR AND NOT EXISTS ${OpenCV_DIR})
     message(FATAL_ERROR "OpenCV_DIR variable is defined but corresponds to non-existing directory")
   endif()
 
   set(proj OpenCV)
   set(proj_DEPENDENCIES)
   set(OpenCV_DEPENDS ${proj})
 
   if(NOT DEFINED OpenCV_DIR)
 
     set(additional_cmake_args
       -DBUILD_opencv_java:BOOL=OFF
       -DBUILD_opencv_ts:BOOL=OFF
       -DBUILD_PERF_TESTS:BOOL=OFF
     )
 
     if(MITK_USE_Python)
       set(CV_PACKAGE_PATH -DPYTHON_PACKAGES_PATH:PATH=${ep_prefix}/lib/python${PYTHON_VERSION_MAJOR}.${PYTHON_VERSION_MINOR}/site-packages)
 
       list(APPEND additional_cmake_args
          -DBUILD_opencv_python:BOOL=ON
          -DBUILD_opencv_python3:BOOL=ON
          #-DBUILD_NEW_PYTHON_SUPPORT:BOOL=ON
          -DPYTHON_DEBUG_LIBRARY:FILEPATH=${PYTHON_DEBUG_LIBRARY}
          -DPYTHON_EXECUTABLE:FILEPATH=${PYTHON_EXECUTABLE}
          -DPYTHON_INCLUDE_DIR:PATH=${PYTHON_INCLUDE_DIR}
          -DPYTHON_INCLUDE_DIR2:PATH=${PYTHON_INCLUDE_DIR2}
          -DPYTHON_LIBRARY:FILEPATH=${PYTHON_LIBRARY}
          ${CV_PACKAGE_PATH}
          #-DPYTHON_LIBRARIES=${PYTHON_LIBRARY}
          #-DPYTHON_DEBUG_LIBRARIES=${PYTHON_DEBUG_LIBRARIES}
           )
     else()
       list(APPEND additional_cmake_args
          -DBUILD_opencv_python:BOOL=OFF
          -DBUILD_opencv_python3:BOOL=OFF
          -DBUILD_opencv_python_bindings_generator:BOOL=OFF
          #-DBUILD_NEW_PYTHON_SUPPORT:BOOL=OFF
           )
     endif()
 
     # 12-05-02, muellerm, added QT usage by OpenCV if QT is used in MITK
     # 12-09-11, muellerm, removed automatic usage again, since this will struggle with the MITK Qt application object
     if(MITK_USE_Qt5)
       list(APPEND additional_cmake_args
            -DWITH_QT:BOOL=OFF
            -DWITH_QT_OPENGL:BOOL=OFF
            -DQT_QMAKE_EXECUTABLE:FILEPATH=${QT_QMAKE_EXECUTABLE}
           )
     endif()
 
     if(CTEST_USE_LAUNCHERS)
       list(APPEND additional_cmake_args
         "-DCMAKE_PROJECT_${proj}_INCLUDE:FILEPATH=${CMAKE_ROOT}/Modules/CTestUseLaunchers.cmake"
       )
     endif()
 
     set(opencv_url ${MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL}/opencv-3.4.1.tar.gz)
     set(opencv_url_md5 a0b7a47899e67b3490ea31edc4f6e8e6)
     ExternalProject_Add(${proj}
       LIST_SEPARATOR ${sep}
       URL ${opencv_url}
       URL_MD5 ${opencv_url_md5}
       CMAKE_GENERATOR ${gen}
+      CMAKE_GENERATOR_PLATFORM ${gen_platform}
       CMAKE_ARGS
         ${ep_common_args}
         -DBUILD_TESTS:BOOL=OFF
         -DBUILD_DOCS:BOOL=OFF
         -DBUILD_EXAMPLES:BOOL=OFF
         -DBUILD_DOXYGEN_DOCS:BOOL=OFF
         -DWITH_CUDA:BOOL=OFF
         -DWITH_VTK:BOOL=OFF
         -DENABLE_CXX11:BOOL=ON
         -DWITH_IPP:BOOL=OFF
         -DBUILD_IPP_IW:BOOL=OFF
         ${additional_cmake_args}
       CMAKE_CACHE_ARGS
         ${ep_common_cache_args}
       CMAKE_CACHE_DEFAULT_ARGS
         ${ep_common_cache_default_args}
       DEPENDS ${proj_DEPENDENCIES}
     )
 
     set(OpenCV_DIR ${ep_prefix})
     mitkFunctionInstallExternalCMakeProject(${proj})
 
   else()
 
     mitkMacroEmptyExternalProject(${proj} "${proj_DEPENDENCIES}")
 
   endif()
 
 endif()
diff --git a/CMakeExternals/OpenIGTLink.cmake b/CMakeExternals/OpenIGTLink.cmake
index d7910aa5e8..691f4c706c 100644
--- a/CMakeExternals/OpenIGTLink.cmake
+++ b/CMakeExternals/OpenIGTLink.cmake
@@ -1,52 +1,53 @@
 #-----------------------------------------------------------------------------
 # OpenIGTLink
 #-----------------------------------------------------------------------------
 if(MITK_USE_OpenIGTLink)
 
   # Sanity checks
   if(DEFINED OpenIGTLink_DIR AND NOT EXISTS ${OpenIGTLink_DIR})
     message(FATAL_ERROR "OpenIGTLink_DIR variable is defined but corresponds to non-existing directory")
   endif()
 
   set(proj OpenIGTLink)
   set(proj_DEPENDENCIES )
   set(${proj}_DEPENDS ${proj})
 
   if(NOT DEFINED OpenIGTLink_DIR)
 
     set(additional_cmake_args )
 
     if(CTEST_USE_LAUNCHERS)
       set(additional_cmake_args
         "-DCMAKE_PROJECT_${proj}_INCLUDE:FILEPATH=${CMAKE_ROOT}/Modules/CTestUseLaunchers.cmake"
       )
     endif()
 
     ExternalProject_Add(${proj}
        URL ${MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL}/OpenIGTLink-54df50de.tar.gz
        URL_MD5 b9fd8351b059f4ec615f2dfd74ab2458
        PATCH_COMMAND ${PATCH_COMMAND} -N -p1 -i ${CMAKE_CURRENT_LIST_DIR}/OpenIGTLink-54df50de.patch
        CMAKE_GENERATOR ${gen}
+       CMAKE_GENERATOR_PLATFORM ${gen_platform}
        CMAKE_ARGS
          ${ep_common_args}
          ${additional_cmake_args}
          -DBUILD_EXAMPLES:BOOL=OFF
          -DOpenIGTLink_PROTOCOL_VERSION_2:BOOL=ON
          -DOpenIGTLink_INSTALL_LIB_DIR:STRING=lib
          -DOpenIGTLink_INSTALL_PACKAGE_DIR:STRING=lib/cmake/OpenIGTLink
          -DOpenIGTLink_INSTALL_NO_DOCUMENTATION:BOOL=ON
        CMAKE_CACHE_ARGS
          ${ep_common_cache_args}
        CMAKE_CACHE_DEFAULT_ARGS
          ${ep_common_cache_default_args}
        DEPENDS ${proj_DEPENDENCIES}
       )
 
     set(OpenIGTLink_DIR "${ep_prefix}/lib/cmake/OpenIGTLink")
 
   else()
 
     mitkMacroEmptyExternalProject(${proj} "${proj_DEPENDENCIES}")
 
   endif()
 endif()
diff --git a/CMakeExternals/PCRE.cmake b/CMakeExternals/PCRE.cmake
index ff450ec786..9487afb1b1 100644
--- a/CMakeExternals/PCRE.cmake
+++ b/CMakeExternals/PCRE.cmake
@@ -1,67 +1,69 @@
 #--------------------------------------------------------------------------
 #  PCRE (Perl Compatible Regular Expressions)
 #--------------------------------------------------------------------------
 if(MITK_USE_PCRE)
   if(DEFINED PCRE_DIR AND NOT EXISTS ${PCRE_DIR})
       message(FATAL_ERROR "PCRE_DIR variable is defined but corresponds to non-existing directory")
    endif()
 
   set(proj PCRE)
   set(${proj}_DEPENDENCIES "")
   set(${proj}_DEPENDS ${proj})
 
   if(NOT PCRE_DIR)
 
     if(UNIX)
       # Some other projects (e.g. Swig) require a pcre-config script which is not
       # generated when using the CMake build system.
       set(configure_cmd
         CONFIGURE_COMMAND <SOURCE_DIR>/./configure
         CC=${CMAKE_C_COMPILER}${CMAKE_C_COMPILER_ARG1}
         CFLAGS=-fPIC
         "CXXFLAGS=-fPIC ${MITK_CXX14_FLAG} ${CMAKE_CXX_FLAGS} ${CMAKE_CXX_FLAGS_RELEASE}"
         "LDFLAGS=${CMAKE_LINKER_FLAGS} ${CMAKE_LINKER_FLAGS_RELEASE} ${_install_rpath_linkflag}"
         CXX=${CMAKE_CXX_COMPILER}${CMAKE_CXX_COMPILER_ARG1}
         --prefix=<INSTALL_DIR>
         --disable-shared
         --enable-jit
       )
     else()
 
       set(additional_cmake_args )
       if(CTEST_USE_LAUNCHERS)
         list(APPEND additional_cmake_args
           "-DCMAKE_PROJECT_${proj}_INCLUDE:FILEPATH=${CMAKE_ROOT}/Modules/CTestUseLaunchers.cmake"
         )
       endif()
 
       set(configure_cmd
+        CMAKE_GENERATOR ${gen}
+        CMAKE_GENERATOR_PLATFORM ${gen_platform}
         CMAKE_ARGS
           ${ep_common_args}
           ${additional_cmake_args}
          "-DCMAKE_C_FLAGS:STRING=${CMAKE_C_FLAGS} -fPIC"
          -DBUILD_SHARED_LIBS:BOOL=OFF
          -DPCRE_BUILD_PCREGREP:BOOL=OFF
          -DPCRE_BUILD_TESTS:BOOL=OFF
          -DPCRE_SUPPORT_JIT:BOOL=ON
        CMAKE_CACHE_ARGS
          ${ep_common_cache_args}
        CMAKE_CACHE_DEFAULT_ARGS
          ${ep_common_cache_default_args}
       )
     endif()
 
     ExternalProject_add(${proj}
       LIST_SEPARATOR ${sep}
       URL ${MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL}/pcre-8.35.tar.gz
       URL_MD5 "ed58bcbe54d3b1d59e9f5415ef45ce1c"
       ${configure_cmd}
       DEPENDS "${${proj}_DEPENDENCIES}"
       )
 
     set(PCRE_DIR ${ep_prefix})
 
   else()
     mitkMacroEmptyExternalProject(${proj} "${${proj}_DEPENDENCIES}")
   endif()
 endif()
diff --git a/CMakeExternals/Poco.cmake b/CMakeExternals/Poco.cmake
index c39dae9fbd..9fa9bfe821 100644
--- a/CMakeExternals/Poco.cmake
+++ b/CMakeExternals/Poco.cmake
@@ -1,69 +1,70 @@
 #-----------------------------------------------------------------------------
 # Poco
 #-----------------------------------------------------------------------------
 
 if(MITK_USE_Poco)
 
   # Sanity checks
   if(DEFINED Poco_DIR AND NOT EXISTS ${Poco_DIR})
     message(FATAL_ERROR "Poco_DIR variable is defined but corresponds to non-existing directory")
   endif()
 
   set(proj Poco)
   set(proj_DEPENDENCIES )
   set(${proj}_DEPENDS ${proj})
 
   if(NOT DEFINED ${proj}_DIR)
 
     set(additional_cmake_args )
     if(CTEST_USE_LAUNCHERS)
       list(APPEND additional_cmake_args
         "-DCMAKE_PROJECT_${proj}_INCLUDE:FILEPATH=${CMAKE_ROOT}/Modules/CTestUseLaunchers.cmake"
       )
     endif()
 
     ExternalProject_Add(${proj}
       LIST_SEPARATOR ${sep}
       URL ${MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL}/poco-1.9.0.tar.gz
       URL_MD5 1011839033f72de138f0c523c2caa121
       CMAKE_GENERATOR ${gen}
+      CMAKE_GENERATOR_PLATFORM ${gen_platform}
       CMAKE_ARGS
         ${ep_common_args}
         ${additional_cmake_args}
         -DENABLE_XML:BOOL=ON
         -DENABLE_JSON:BOOL=ON
         -DENABLE_MONGODB:BOOL=OFF
         -DENABLE_PDF:BOOL=OFF
         -DENABLE_UTIL:BOOL=ON
         -DENABLE_NET:BOOL=ON
         -DENABLE_NETSSL:BOOL=OFF
         -DENABLE_NETSSL_WIN:BOOL=OFF
         -DENABLE_CRYPTO:BOOL=OFF
         -DENABLE_DATA:BOOL=OFF
         -DENABLE_DATA_SQLITE:BOOL=OFF
         -DENABLE_DATA_MYSQL:BOOL=OFF
         -DENABLE_DATA_ODBC:BOOL=OFF
         -DENABLE_SEVENZIP:BOOL=OFF
         -DENABLE_ZIP:BOOL=ON
         -DENABLE_APACHECONNECTOR:BOOL=OFF
         -DENABLE_CPPPARSER:BOOL=OFF
         -DENABLE_POCODOC:BOOL=OFF
         -DENABLE_PAGECOMPILER:BOOL=OFF
         -DENABLE_PAGECOMPILER_FILE2PAGE:BOOL=OFF
       CMAKE_CACHE_ARGS
         ${ep_common_cache_args}
       CMAKE_CACHE_DEFAULT_ARGS
         ${ep_common_cache_default_args}
       DEPENDS ${proj_DEPENDENCIES}
      )
 
     set(${proj}_DIR ${ep_prefix})
     mitkFunctionInstallExternalCMakeProject(${proj})
 
   else()
 
     mitkMacroEmptyExternalProject(${proj} "${proj_DEPENDENCIES}")
 
   endif()
 
 endif()
diff --git a/CMakeExternals/Qwt.cmake b/CMakeExternals/Qwt.cmake
index f8242259cb..b397f9e042 100644
--- a/CMakeExternals/Qwt.cmake
+++ b/CMakeExternals/Qwt.cmake
@@ -1,61 +1,62 @@
 #-----------------------------------------------------------------------------
 # Qwt
 #-----------------------------------------------------------------------------
 
 if(MITK_USE_Qwt)
 
 # Sanity checks
 if(DEFINED Qwt_DIR AND NOT EXISTS ${Qwt_DIR})
   message(FATAL_ERROR "Qwt_DIR variable is defined but corresponds to non-existing directory")
 endif()
 
 set(proj Qwt)
 set(proj_DEPENDENCIES )
 set(${proj}_DEPENDS ${proj})
 
 if(NOT DEFINED ${proj}_DIR)
 
   set(patch_cmd ${CMAKE_COMMAND} -Dproj:STRING=${proj} -Dproj_target:STRING=qwt -P ${CMAKE_CURRENT_LIST_DIR}/GenerateDefaultCMakeBuildSystem.cmake)
   set(qt54patch_cmd ${CMAKE_COMMAND} -DTEMPLATE_FILE:FILEPATH=${MITK_SOURCE_DIR}/CMakeExternals/EmptyFileForPatching.dummy -P ${MITK_SOURCE_DIR}/CMakeExternals/PatchQwt-6.1.0.cmake)
 
   set(additional_cmake_args
   "-DQt5Svg_DIR:PATH=${Qt5Svg_DIR}"
   "-DQt5OpenGL_DIR:PATH=${Qt5OpenGL_DIR}"
   "-DQt5PrintSupport_DIR:PATH=${Qt5PrintSupport_DIR}"
   "-DQt5Concurrent_DIR:PATH=${Qt5Concurrent_DIR}"
   "-DQt5Designer_DIR:PATH=${Qt5_DIR}Designer"
   )
   if(CTEST_USE_LAUNCHERS)
     list(APPEND additional_cmake_args
       "-DCMAKE_PROJECT_${proj}_INCLUDE:FILEPATH=${CMAKE_ROOT}/Modules/CTestUseLaunchers.cmake"
     )
   endif()
 
   ExternalProject_Add(${proj}
      LIST_SEPARATOR ${sep}
      URL ${MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL}/qwt-6.1.0.tar.bz2
      URL_MD5 aef0437b37f191067a6a9dc01c30ba64
      PATCH_COMMAND ${PATCH_COMMAND} -N -p1 -i ${CMAKE_CURRENT_LIST_DIR}/Qwt-6.1.0.patch
        COMMAND ${CMAKE_COMMAND} -Dproj=${proj} -Dproj_target:STRING=qwt -P ${CMAKE_CURRENT_LIST_DIR}/GenerateDefaultCMakeBuildSystem.cmake
      CMAKE_GENERATOR ${gen}
+     CMAKE_GENERATOR_PLATFORM ${gen_platform}
      CMAKE_ARGS
        ${ep_common_args}
        ${additional_cmake_args}
        ${qt_project_args}
      CMAKE_CACHE_ARGS
        ${ep_common_cache_args}
      CMAKE_CACHE_DEFAULT_ARGS
        ${ep_common_cache_default_args}
      DEPENDS ${proj_DEPENDENCIES}
     )
 
   set(${proj}_DIR ${ep_prefix})
   mitkFunctionInstallExternalCMakeProject(${proj})
 
 else()
 
   mitkMacroEmptyExternalProject(${proj} "${proj_DEPENDENCIES}")
 
 endif()
 
 endif()
diff --git a/CMakeExternals/Raptor2.cmake b/CMakeExternals/Raptor2.cmake
index 4252b4469e..5fed212c3e 100644
--- a/CMakeExternals/Raptor2.cmake
+++ b/CMakeExternals/Raptor2.cmake
@@ -1,71 +1,72 @@
 #-----------------------------------------------------------------------------
 # raptor2
 #-----------------------------------------------------------------------------
 
 if(MITK_USE_Raptor2)
 
 # Sanity checks
 if(DEFINED Raptor2_DIR AND NOT EXISTS ${Raptor2_DIR})
   message(FATAL_ERROR "Raptor2_DIR variable is defined but corresponds to non-existing directory")
 endif()
 
 set(proj Raptor2)
 set(proj_DEPENDENCIES )
 set(${proj}_DEPENDS ${proj})
 
 if(NOT DEFINED Raptor2_DIR)
 
   set(additional_cmake_args )
   if(CTEST_USE_LAUNCHERS)
     list(APPEND additional_cmake_args
       "-DCMAKE_PROJECT_${proj}_INCLUDE:FILEPATH=${CMAKE_ROOT}/Modules/CTestUseLaunchers.cmake"
     )
   endif()
 
   ExternalProject_Add(${proj}
      LIST_SEPARATOR ${sep}
      URL ${MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL}/raptor2-2.0.15.tar.gz
      URL_MD5 a39f6c07ddb20d7dd2ff1f95fa21e2cd
      PATCH_COMMAND ${PATCH_COMMAND} -N -p1 -i ${CMAKE_CURRENT_LIST_DIR}/Raptor2-2.0.15.patch
      CMAKE_GENERATOR ${gen}
+     CMAKE_GENERATOR_PLATFORM ${gen_platform}
      CMAKE_ARGS
        ${ep_common_args}
        ${additional_cmake_args}
        -DRAPTOR_ENABLE_TESTING:BOOL=OFF
        -DRAPTOR_PARSER_GRDDL:BOOL=OFF
        -DRAPTOR_PARSER_GUESS:BOOL=OFF
        -DRAPTOR_PARSER_JSON:BOOL=OFF
        -DRAPTOR_PARSER_NQUADS:BOOL=ON
        -DRAPTOR_PARSER_NTRIPLES:BOOL=ON
        -DRAPTOR_PARSER_RDFA:BOOL=OFF
        -DRAPTOR_PARSER_RDFXML:BOOL=OFF
        -DRAPTOR_PARSER_RSS:BOOL=OFF
        -DRAPTOR_PARSER_TRIG:BOOL=OFF
        -DRAPTOR_PARSER_TURTLE:BOOL=ON
        -DRAPTOR_SERIALIZER_ATOM:BOOL=OFF
        -DRAPTOR_SERIALIZER_DOT:BOOL=OFF
        -DRAPTOR_SERIALIZER_HTML:BOOL=OFF
        -DRAPTOR_SERIALIZER_JSON:BOOL=OFF
        -DRAPTOR_SERIALIZER_NQUADS:BOOL=ON
        -DRAPTOR_SERIALIZER_NTRIPLES:BOOL=ON
        -DRAPTOR_SERIALIZER_RDFXML:BOOL=OFF
        -DRAPTOR_SERIALIZER_RDFXML_ABBREV:BOOL=OFF
        -DRAPTOR_SERIALIZER_RSS_1_0:BOOL=OFF
        -DRAPTOR_SERIALIZER_TURTLE:BOOL=ON
      CMAKE_CACHE_ARGS
        ${ep_common_cache_args}
      CMAKE_CACHE_DEFAULT_ARGS
        ${ep_common_cache_default_args}
      DEPENDS ${proj_DEPENDENCIES}
     )
 
   set(${proj}_DIR ${ep_prefix}/lib/raptor2/cmake)
   mitkFunctionInstallExternalCMakeProject(${proj})
 
 else()
 
   mitkMacroEmptyExternalProject(${proj} "${proj_DEPENDENCIES}")
 
 endif()
 
 endif()
diff --git a/CMakeExternals/Rasqal.cmake b/CMakeExternals/Rasqal.cmake
index acc0258201..e89464272e 100644
--- a/CMakeExternals/Rasqal.cmake
+++ b/CMakeExternals/Rasqal.cmake
@@ -1,55 +1,56 @@
 #-----------------------------------------------------------------------------
 # rasqal
 #-----------------------------------------------------------------------------
 
 if(MITK_USE_Rasqal)
 
 # Sanity checks
 if(DEFINED Rasqal_DIR AND NOT EXISTS ${Rasqal_DIR})
   message(FATAL_ERROR "Rasqal_DIR variable is defined but corresponds to non-existing directory")
 endif()
 
 set(proj Rasqal)
 set(proj_DEPENDENCIES ${Raptor2_DEPENDS} ${PCRE_DEPENDS})
 set(${proj}_DEPENDS ${proj})
 
 if(NOT DEFINED Rasqal_DIR)
 
   set(additional_cmake_args )
   if(CTEST_USE_LAUNCHERS)
     list(APPEND additional_cmake_args
       "-DCMAKE_PROJECT_${proj}_INCLUDE:FILEPATH=${CMAKE_ROOT}/Modules/CTestUseLaunchers.cmake"
     )
   endif()
 
   ExternalProject_Add(${proj}
      LIST_SEPARATOR ${sep}
      URL ${MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL}/rasqal-0.9.32.tar.gz
      URL_MD5 dc7c6107de00c47f85f6ab7db164a136
      PATCH_COMMAND ${PATCH_COMMAND} -N -p1 -i ${CMAKE_CURRENT_LIST_DIR}/Rasqal-0.9.32.patch
-     LIST_SEPARATOR ^^
+     LIST_SEPARATOR ${sep}
      CMAKE_GENERATOR ${gen}
+     CMAKE_GENERATOR_PLATFORM ${gen_platform}
      CMAKE_ARGS
        ${ep_common_args}
        ${additional_cmake_args}
        "-DCMAKE_C_FLAGS:STRING=-DPCRE_STATIC ${CMAKE_C_FLAGS}"
        -DRASQAL_REGEX:STRING=pcre
        -DCMAKE_PREFIX_PATH:STRING=${PCRE_DIR}^^${REDLAND_INSTALL_DIR}
        -DPCRE_INCLUDE_DIR:PATH=${PCRE_DIR}/include
      CMAKE_CACHE_ARGS
        ${ep_common_cache_args}
      CMAKE_CACHE_DEFAULT_ARGS
        ${ep_common_cache_default_args}
      DEPENDS ${proj_DEPENDENCIES}
     )
 
   set(${proj}_DIR ${ep_prefix}/lib/rasqal/cmake)
   mitkFunctionInstallExternalCMakeProject(${proj})
 
 else()
 
   mitkMacroEmptyExternalProject(${proj} "${proj_DEPENDENCIES}")
 
 endif()
 
 endif()
diff --git a/CMakeExternals/Redland.cmake b/CMakeExternals/Redland.cmake
index f8c3f1869c..6ba7d5dac3 100644
--- a/CMakeExternals/Redland.cmake
+++ b/CMakeExternals/Redland.cmake
@@ -1,51 +1,52 @@
 #-----------------------------------------------------------------------------
 # redland
 #-----------------------------------------------------------------------------
 
 if(MITK_USE_Redland)
 
 # Sanity checks
 if(DEFINED Redland_DIR AND NOT EXISTS ${Redland_DIR})
   message(FATAL_ERROR "Redland_DIR variable is defined but corresponds to non-existing directory")
 endif()
 
 set(proj Redland)
 set(proj_DEPENDENCIES ${Raptor2_DEPENDS} ${Rasqal_DEPENDS})
 set(${proj}_DEPENDS ${proj})
 
 if(NOT DEFINED Redland_DIR)
 
   set(additional_cmake_args )
   if(CTEST_USE_LAUNCHERS)
     list(APPEND additional_cmake_args
       "-DCMAKE_PROJECT_${proj}_INCLUDE:FILEPATH=${CMAKE_ROOT}/Modules/CTestUseLaunchers.cmake"
     )
   endif()
 
   ExternalProject_Add(${proj}
      LIST_SEPARATOR ${sep}
      URL ${MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL}/redland-1.0.17.tar.gz
      URL_MD5 e5be03eda13ef68aabab6e42aa67715e
      PATCH_COMMAND ${PATCH_COMMAND} -N -p1 -i ${CMAKE_CURRENT_LIST_DIR}/Redland-1.0.17.patch
      CMAKE_GENERATOR ${gen}
+     CMAKE_GENERATOR_PLATFORM ${gen_platform}
      CMAKE_ARGS
        ${ep_common_args}
        ${additional_cmake_args}
        -DWITH_THREADS:BOOL=OFF
      CMAKE_CACHE_ARGS
        ${ep_common_cache_args}
      CMAKE_CACHE_DEFAULT_ARGS
        ${ep_common_cache_default_args}
      DEPENDS ${proj_DEPENDENCIES}
     )
 
   set(${proj}_DIR ${ep_prefix}/lib/redland/cmake)
   mitkFunctionInstallExternalCMakeProject(${proj})
 
 else()
 
   mitkMacroEmptyExternalProject(${proj} "${proj_DEPENDENCIES}")
 
 endif()
 
 endif()
diff --git a/CMakeExternals/SimpleITK.cmake b/CMakeExternals/SimpleITK.cmake
index 1f6bff9370..27e80f0383 100644
--- a/CMakeExternals/SimpleITK.cmake
+++ b/CMakeExternals/SimpleITK.cmake
@@ -1,137 +1,139 @@
 #-----------------------------------------------------------------------------
 # SimpleITK
 #-----------------------------------------------------------------------------
 
 if(MITK_USE_SimpleITK)
 
  # Sanity checks
  if(DEFINED SimpleITK_DIR AND NOT EXISTS ${SimpleITK_DIR})
    message(FATAL_ERROR "SimpleITK_DIR variable is defined but corresponds to non-existing directory")
  endif()
 
   set(proj SimpleITK)
   set(proj_DEPENDENCIES ITK GDCM SWIG)
 
   if(MITK_USE_OpenCV)
     list(APPEND proj_DEPENDENCIES OpenCV)
   endif()
 
   set(SimpleITK_DEPENDS ${proj})
 
   if(NOT DEFINED SimpleITK_DIR)
 
     set(additional_cmake_args )
 
     list(APPEND additional_cmake_args
          -DWRAP_CSHARP:BOOL=OFF
          -DWRAP_TCL:BOOL=OFF
          -DWRAP_LUA:BOOL=OFF
          -DWRAP_PYTHON:BOOL=OFF
          -DWRAP_JAVA:BOOL=OFF
          -DWRAP_RUBY:BOOL=OFF
          -DWRAP_R:BOOL=OFF
         )
 
     if(MITK_USE_Python)
       list(APPEND additional_cmake_args
            -DWRAP_PYTHON:BOOL=ON
            -DPYTHON_EXECUTABLE:FILEPATH=${PYTHON_EXECUTABLE}
            -DPYTHON_INCLUDE_DIR:PATH=${PYTHON_INCLUDE_DIR}
            -DPYTHON_INCLUDE_DIR2:PATH=${PYTHON_INCLUDE_DIR2}
            -DPYTHON_LIBRARY:FILEPATH=${PYTHON_LIBRARY}
           )
     endif()
 
     if(CTEST_USE_LAUNCHERS)
       list(APPEND additional_cmake_args
         "-DCMAKE_PROJECT_${proj}_INCLUDE:FILEPATH=${CMAKE_ROOT}/Modules/CTestUseLaunchers.cmake"
       )
     endif()
 
     #TODO: Installer and testing works only with static libs on MAC
     set(_build_shared ON)
     if(APPLE)
       set(_build_shared OFF)
     endif()
     ExternalProject_Add(${proj}
        LIST_SEPARATOR ${sep}
        #GIT_REPOSITORY https://github.com/SimpleITK/SimpleITK.git
        # URL https://github.com/SimpleITK/SimpleITK/releases/download/v1.0.1/SimpleITK-1.0.1.tar.xz
        URL ${MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL}/SimpleITK_9d510bef.tar.gz
        URL_MD5 c34f4d5259594bf1adf1d83f13228cbe
        # PATCH_COMMAND ${PATCH_COMMAND} -N -p1 -i ${CMAKE_CURRENT_LIST_DIR}/SimpleITK-0.8.1.patch
        INSTALL_COMMAND ""
        SOURCE_SUBDIR SuperBuild
+       CMAKE_GENERATOR ${gen}
+       CMAKE_GENERATOR_PLATFORM ${gen_platform}
        CMAKE_ARGS
          ${ep_common_cache_default_args}
          # -DCMAKE_BUILD_WITH_INSTALL_RPATH:BOOL=ON
       CMAKE_CACHE_ARGS
          ${ep_common_cache_args}
          ${additional_cmake_args}
          -DBUILD_SHARED_LIBS:BOOL=${_build_shared}
          -DSimpleITK_BUILD_DISTRIBUTE:BOOL=ON
          -DSimpleITK_PYTHON_THREADS:BOOL=ON
          -DSimpleITK_USE_SYSTEM_ITK:BOOL=ON
          -DITK_DIR:PATH=${ITK_DIR}
          -DSimpleITK_USE_SYSTEM_SWIG:BOOL=ON
          -DSWIG_DIR:PATH=${SWIG_DIR}
          -DSWIG_EXECUTABLE:FILEPATH=${SWIG_EXECUTABLE}
          -DBUILD_EXAMPLES:BOOL=OFF
          -DBUILD_TESTING:BOOL=OFF
          -DGDCM_DIR:PATH=${GDCM_DIR}
          -DHDF5_DIR:PATH=${HDF5_DIR}
          -DCMAKE_CXX_COMPILER:FILEPATH=${CMAKE_CXX_COMPILER}
          -DCMAKE_CXX_COMPILER_AR:FILEPATH=${CMAKE_CXX_COMPILER_AR}
          -DCMAKE_CXX_COMPILER_RANLIB:FILEPATH=${CMAKE_CXX_COMPILER_RANLIB}
          -DCMAKE_C_COMPILER:FILEPATH=${CMAKE_C_COMPILER}
          -DCMAKE_C_COMPILER_AR:FILEPATH=${CMAKE_C_COMPILER_AR}
          -DCMAKE_C_COMPILER_RANLIB:FILEPATH=${CMAKE_C_COMPILER_RANLIB}
        CMAKE_CACHE_DEFAULT_ARGS
          ${ep_common_cache_default_args}
        DEPENDS ${proj_DEPENDENCIES}
       )
 
     if( MITK_USE_Python )
       set(_sitk_build_dir ${ep_prefix}/src/SimpleITK-build)
       # Build python distribution with easy install. If a own runtime is used
       # embed the egg into the site-package folder of the runtime
 
       # Note: Userbase install could also be relevant in some cases Probably windows wants to
       # install to Lib/python3.6/
       # Build egg into custom user base folder and deploy it later into installer
       # https://pythonhosted.org/setuptools/easy_install.html#use-the-user-option-and-customize-pythonuserbase
       # PYTHONUSERBASE=${_install_dir} ${PYTHON_EXECUTABLE} setup.py --user
 
       # PythonDir needs to be fixed for the python interpreter by
       # changing dir delimiter for Windows
 
       set(_install_dir ${ep_prefix} )
       set(_pythonpath ${ep_prefix}/lib/python${PYTHON_VERSION_MAJOR}.${PYTHON_VERSION_MINOR}/site-packages )
 
       if(WIN32)
         STRING(REPLACE "/" "\\\\" _install_dir ${_install_dir})
       else()
         # escape spaces in the install path for linux
         STRING(REPLACE " " "\ " _install_dir ${_install_dir})
       endif()
 
       ExternalProject_Add_Step(${proj} sitk_python_install_step
         COMMAND ${CMAKE_COMMAND} -E env PYTHONPATH=${_pythonpath}$<SEMICOLON>${ep_prefix}/Lib/site-packages ${PYTHON_EXECUTABLE} Packaging/setup.py install --prefix=${_install_dir}
         DEPENDEES install
         WORKING_DIRECTORY ${_sitk_build_dir}/SimpleITK-build/Wrapping/Python/
       )
 
     endif()
 
     mitkFunctionInstallExternalCMakeProject(${proj})
     # Still need to install the SimpleITK Python wrappings
   else()
 
     mitkMacroEmptyExternalProject(${proj} "${proj_DEPENDENCIES}")
 
   endif()
 
   set(SimpleITK_DIR ${ep_prefix}/src/SimpleITK-build/SimpleITK-build)
 
 endif()
 
diff --git a/CMakeExternals/VTK.cmake b/CMakeExternals/VTK.cmake
index 543363ccd6..1f71e745bd 100644
--- a/CMakeExternals/VTK.cmake
+++ b/CMakeExternals/VTK.cmake
@@ -1,98 +1,99 @@
 #-----------------------------------------------------------------------------
 # VTK
 #-----------------------------------------------------------------------------
 
 if(WIN32)
   option(VTK_USE_SYSTEM_FREETYPE OFF)
 else(WIN32)
   option(VTK_USE_SYSTEM_FREETYPE ON)
 endif(WIN32)
 
 # Sanity checks
 if(DEFINED VTK_DIR AND NOT EXISTS ${VTK_DIR})
   message(FATAL_ERROR "VTK_DIR variable is defined but corresponds to non-existing directory")
 endif()
 
 set(proj VTK)
 set(proj_DEPENDENCIES )
 set(VTK_DEPENDS ${proj})
 
 if(MITK_USE_HDF5)
   list(APPEND proj_DEPENDENCIES HDF5)
 endif()
 
 if(NOT DEFINED VTK_DIR)
 
   set(additional_cmake_args )
 
   # Optionally enable memory leak checks for any objects derived from vtkObject. This
   # will force unit tests to fail if they have any of these memory leaks.
   option(MITK_VTK_DEBUG_LEAKS OFF)
   mark_as_advanced(MITK_VTK_DEBUG_LEAKS)
   list(APPEND additional_cmake_args
        -DVTK_DEBUG_LEAKS:BOOL=${MITK_VTK_DEBUG_LEAKS}
       )
 
   if(MITK_USE_Python)
     set(_vtk_install_python_dir -DVTK_INSTALL_PYTHON_MODULE_DIR:PATH=${ep_prefix}/lib/python${PYTHON_VERSION_MAJOR}.${PYTHON_VERSION_MINOR}/site-packages)
 
     list(APPEND additional_cmake_args
          -DVTK_WRAP_PYTHON:BOOL=ON
          -DVTK_USE_TK:BOOL=OFF
          -DVTK_WINDOWS_PYTHON_DEBUGGABLE:BOOL=OFF
          -DPYTHON_EXECUTABLE:FILEPATH=${PYTHON_EXECUTABLE}
          -DPYTHON_INCLUDE_DIR:PATH=${PYTHON_INCLUDE_DIR}
          -DPYTHON_INCLUDE_DIR2:PATH=${PYTHON_INCLUDE_DIR2}
          -DPYTHON_LIBRARY:FILEPATH=${PYTHON_LIBRARY}
          -DVTK_PYTHON_VERSION:STRING=3
          ${_vtk_install_python_dir}
         )
   else()
     list(APPEND additional_cmake_args
          -DVTK_WRAP_PYTHON:BOOL=OFF
          -DVTK_WINDOWS_PYTHON_DEBUGGABLE:BOOL=OFF
         )
   endif()
 
   if(MITK_USE_Qt5)
     list(APPEND additional_cmake_args
         -DVTK_Group_Qt:BOOL=ON
         -DQt5_DIR:PATH=${Qt5_DIR}
      )
   endif()
 
   if(CTEST_USE_LAUNCHERS)
     list(APPEND additional_cmake_args
       "-DCMAKE_PROJECT_${proj}_INCLUDE:FILEPATH=${CMAKE_ROOT}/Modules/CTestUseLaunchers.cmake"
     )
   endif()
 
   ExternalProject_Add(${proj}
     LIST_SEPARATOR ${sep}
     URL ${MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL}/VTK-8.1.0.tar.gz
     URL_MD5 4fa5eadbc8723ba0b8d203f05376d932
     CMAKE_GENERATOR ${gen}
+    CMAKE_GENERATOR_PLATFORM ${gen_platform}
     CMAKE_ARGS
         ${ep_common_args}
         -DVTK_WRAP_TCL:BOOL=OFF
         -DVTK_WRAP_PYTHON:BOOL=OFF
         -DVTK_WRAP_JAVA:BOOL=OFF
         -DVTK_USE_SYSTEM_FREETYPE:BOOL=${VTK_USE_SYSTEM_FREETYPE}
         -DVTK_LEGACY_REMOVE:BOOL=ON
         -DModule_vtkTestingRendering:BOOL=ON
         ${additional_cmake_args}
     CMAKE_CACHE_ARGS
       ${ep_common_cache_args}
     CMAKE_CACHE_DEFAULT_ARGS
       ${ep_common_cache_default_args}
     DEPENDS ${proj_DEPENDENCIES}
   )
 
   set(VTK_DIR ${ep_prefix})
   mitkFunctionInstallExternalCMakeProject(${proj})
 
 else()
 
   mitkMacroEmptyExternalProject(${proj} "${proj_DEPENDENCIES}")
 
 endif()
diff --git a/CMakeExternals/Vigra.cmake b/CMakeExternals/Vigra.cmake
index 2b47454640..80e0fd99ee 100644
--- a/CMakeExternals/Vigra.cmake
+++ b/CMakeExternals/Vigra.cmake
@@ -1,64 +1,65 @@
 #-----------------------------------------------------------------------------
 # VIGRA
 #-----------------------------------------------------------------------------
 
 if(MITK_USE_Vigra)
 
   # Sanity checks
   if(DEFINED Vigra_DIR AND NOT EXISTS ${Vigra_DIR})
     message(FATAL_ERROR "Vigra_DIR variable is defined but corresponds to non-existing directory")
   endif()
 
   if(NOT ${MITK_USE_HDF5})
     message(FATAL_ERROR "HDF5 is required for Vigra. Please enable it.")
   endif()
 
   set(proj Vigra)
   set(proj_DEPENDENCIES HDF5)
   set(Vigra_DEPENDS ${proj})
 
   # If a mac ports installation is present some imaging-io-libraries may interfere with the vigra build.
   # Hence, we exclude them here.
   set(mac_additional_cmake_args)
   if(APPLE)
     set(mac_additional_cmake_args -DJPEG_INCLUDE_DIR= -DJPEG_LIBRARY= -DTIFF_INCLUDE_DIR= -DTIFF_LIBRARY= -DPNG_LIBRARY_RELEASE= -DPNG_PNG_INCLUDE_DIR= )
   endif()
 
   if(NOT DEFINED Vigra_DIR)
 
     set(additional_cmake_args )
     if(CTEST_USE_LAUNCHERS)
       list(APPEND additional_cmake_args
         "-DCMAKE_PROJECT_${proj}_INCLUDE:FILEPATH=${CMAKE_ROOT}/Modules/CTestUseLaunchers.cmake"
       )
     endif()
 
     ExternalProject_Add(${proj}
        URL ${MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL}/vigra-1.10.0-src.tar.gz
        URL_MD5 4f963f0be4fcb8b06271c2aa40baa9be
        PATCH_COMMAND ${PATCH_COMMAND} -N -p1 -i ${CMAKE_CURRENT_LIST_DIR}/Vigra.patch
        CMAKE_GENERATOR ${gen}
+       CMAKE_GENERATOR_PLATFORM ${gen_platform}
        CMAKE_ARGS
          ${ep_common_args}
          ${additional_cmake_args}
          ${mac_additional_cmake_args}
          -DAUTOEXEC_TESTS:BOOL=OFF
          -DWITH_VIGRANUMPY:BOOL=OFF
          -DHDF5_DIR:PATH=${HDF5_DIR}
          -DCMAKE_INSTALL_RPATH_USE_LINK_PATH:BOOL=TRUE
          -DCMAKE_INSTALL_PREFIX:PATH=<INSTALL_DIR>
        CMAKE_CACHE_ARGS
          ${ep_common_cache_args}
        CMAKE_CACHE_DEFAULT_ARGS
          ${ep_common_cache_default_args}
        DEPENDS ${proj_DEPENDENCIES}
       )
 
     set(Vigra_DIR ${ep_prefix})
 
   else()
 
     mitkMacroEmptyExternalProject(${proj} "${proj_DEPENDENCIES}")
 
   endif()
 endif(MITK_USE_Vigra)
diff --git a/CMakeExternals/ZLIB.cmake b/CMakeExternals/ZLIB.cmake
index 458878b8b3..9c2aafa86b 100644
--- a/CMakeExternals/ZLIB.cmake
+++ b/CMakeExternals/ZLIB.cmake
@@ -1,73 +1,75 @@
 #------------------------------------------------------------------
 # ZLIB
 #------------------------------------------------------------------
 if(MITK_USE_ZLIB)
 
   set(proj ZLIB)
   set(proj_DEPENDENCIES )
   set(ZLIB_DEPENDS ${proj})
 
   if(NOT DEFINED ZLIB_DIR)
 
     set(additional_cmake_args )
     if(CTEST_USE_LAUNCHERS)
       list(APPEND additional_cmake_args
         "-DCMAKE_PROJECT_${proj}_INCLUDE:FILEPATH=${CMAKE_ROOT}/Modules/CTestUseLaunchers.cmake"
       )
     endif()
 
     # Using the ZLIB from CTK:
     # https://github.com/commontk/zlib
     ExternalProject_Add(${proj}
       LIST_SEPARATOR ${sep}
       URL ${MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL}/zlib-66a75305.tar.gz
       URL_MD5 "4c3f572b487ae7947fd88ec363533bc5"
+      CMAKE_GENERATOR ${gen}
+      CMAKE_GENERATOR_PLATFORM ${gen_platform}
       CMAKE_ARGS
         ${ep_common_args}
         ${additional_cmake_args}
       CMAKE_CACHE_ARGS
         ${ep_common_cache_args}
         -DBUILD_SHARED_LIBS:BOOL=OFF
         -DZLIB_MANGLE_PREFIX:STRING=mitk_zlib_
         -DZLIB_INSTALL_INCLUDE_DIR:STRING=include/mitk_zlib
       CMAKE_CACHE_DEFAULT_ARGS
         ${ep_common_cache_default_args}
       DEPENDS ${proj_DEPENDENCIES}
       )
     set(ZLIB_DIR ${ep_prefix})
     set(ZLIB_INCLUDE_DIR ${ZLIB_DIR}/include/mitk_zlib)
 
     install(DIRECTORY ${ZLIB_INCLUDE_DIR}
             DESTINATION include
             COMPONENT dev)
 
     find_library(ZLIB_LIBRARY_RELEASE NAMES zlib
                  PATHS ${ZLIB_DIR}
                  PATH_SUFFIXES lib lib/Release
                  NO_DEFAULT_PATH)
     find_library(ZLIB_LIBRARY_DEBUG NAMES zlibd
                  PATHS ${ZLIB_DIR}
                  PATH_SUFFIXES lib lib/Debug
                  NO_DEFAULT_PATH)
 
     set(ZLIB_LIBRARY )
     if(ZLIB_LIBRARY_RELEASE)
       list(APPEND ZLIB_LIBRARY ${ZLIB_LIBRARY_RELEASE})
       install(FILES ${ZLIB_LIBRARY_RELEASE}
               DESTINATION lib
               CONFIGURATIONS Release
               COMPONENT dev)
     endif()
     if(ZLIB_LIBRARY_DEBUG)
       list(APPEND ZLIB_LIBRARY ${ZLIB_LIBRARY_DEBUG})
       install(FILES ${ZLIB_LIBRARY_DEBUG}
               DESTINATION lib
               CONFIGURATIONS Debug
               COMPONENT dev)
     endif()
 
   else()
     mitkMacroEmptyExternalProject(${proj} "${proj_DEPENDENCIES}")
   endif()
 endif()
 
diff --git a/CMakeExternals/tinyxml.cmake b/CMakeExternals/tinyxml.cmake
index 23efbe1dba..74391bee27 100644
--- a/CMakeExternals/tinyxml.cmake
+++ b/CMakeExternals/tinyxml.cmake
@@ -1,51 +1,52 @@
 #-----------------------------------------------------------------------------
 # tinyxml
 #-----------------------------------------------------------------------------
 
 # Sanity checks
 if(DEFINED tinyxml_DIR AND NOT EXISTS ${tinyxml_DIR})
   message(FATAL_ERROR "tinyxml_DIR variable is defined but corresponds to non-existing directory")
 endif()
 
 set(proj tinyxml)
 set(proj_DEPENDENCIES )
 set(${proj}_DEPENDS ${proj})
 
 if(NOT DEFINED tinyxml_DIR)
 
   set(additional_cmake_args )
   if(WIN32)
     set(additional_cmake_args -DBUILD_SHARED_LIBS:BOOL=OFF)
   endif()
 
   if(CTEST_USE_LAUNCHERS)
     list(APPEND additional_cmake_args
       "-DCMAKE_PROJECT_${proj}_INCLUDE:FILEPATH=${CMAKE_ROOT}/Modules/CTestUseLaunchers.cmake"
     )
   endif()
 
   ExternalProject_Add(${proj}
      LIST_SEPARATOR ${sep}
      URL ${MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL}/tinyxml_2_6_2.tar.gz
      URL_MD5 c1b864c96804a10526540c664ade67f0
      PATCH_COMMAND ${PATCH_COMMAND} -N -p1 -i ${CMAKE_CURRENT_LIST_DIR}/tinyxml-2.6.2.patch
        COMMAND ${CMAKE_COMMAND} -Dproj=${proj} -Dproj_target:STRING=tinyxml -P ${CMAKE_CURRENT_LIST_DIR}/GenerateDefaultCMakeBuildSystem.cmake
      CMAKE_GENERATOR ${gen}
+     CMAKE_GENERATOR_PLATFORM ${gen_platform}
      CMAKE_ARGS
        ${ep_common_args}
        ${additional_cmake_args}
      CMAKE_CACHE_ARGS
        ${ep_common_cache_args}
      CMAKE_CACHE_DEFAULT_ARGS
        ${ep_common_cache_default_args}
      DEPENDS ${proj_DEPENDENCIES}
     )
 
   set(${proj}_DIR ${ep_prefix})
   mitkFunctionInstallExternalCMakeProject(${proj})
 
 else()
 
   mitkMacroEmptyExternalProject(${proj} "${proj_DEPENDENCIES}")
 
 endif()
diff --git a/SuperBuild.cmake b/SuperBuild.cmake
index 68b969778d..de08759fba 100644
--- a/SuperBuild.cmake
+++ b/SuperBuild.cmake
@@ -1,460 +1,463 @@
 include(mitkFunctionInstallExternalCMakeProject)
 
 #-----------------------------------------------------------------------------
 # 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)
 
 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()
 
 #-----------------------------------------------------------------------------
 # ExternalProjects
 #-----------------------------------------------------------------------------
 
 get_property(external_projects GLOBAL PROPERTY MITK_EXTERNAL_PROJECTS)
 
 if(MITK_CTEST_SCRIPT_MODE)
   # Write a file containing the list of enabled external project targets.
   # This file can be read by a ctest script to separately build projects.
   set(SUPERBUILD_TARGETS )
   foreach(proj ${external_projects})
     if(MITK_USE_${proj})
       list(APPEND SUPERBUILD_TARGETS ${proj})
     endif()
   endforeach()
   file(WRITE "${CMAKE_BINARY_DIR}/SuperBuildTargets.cmake" "set(SUPERBUILD_TARGETS ${SUPERBUILD_TARGETS})")
 endif()
 
 # 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()
 
 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()
 
 # 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()
 
 #-----------------------------------------------------------------------------
 # 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()
 
+set(gen_platform ${CMAKE_GENERATOR_PLATFORM})
+
 # 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 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=${CMAKE_CXX_EXTENSIONS}
   -DCMAKE_CXX_STANDARD:STRING=${CMAKE_CXX_STANDARD}
   -DCMAKE_CXX_STANDARD_REQUIRED:BOOL=${CMAKE_CXX_STANDARD_REQUIRED}
   -DCMAKE_MACOSX_RPATH:BOOL=TRUE
   "-DCMAKE_INSTALL_RPATH:STRING=${_install_rpath}"
   -DBUILD_TESTING:BOOL=OFF
   -DCMAKE_INSTALL_PREFIX:PATH=<INSTALL_DIR>
   -DBUILD_SHARED_LIBS:BOOL=ON
   -DCMAKE_BUILD_TYPE:STRING=${CMAKE_BUILD_TYPE}
   -DCMAKE_C_COMPILER:FILEPATH=${CMAKE_C_COMPILER}
   -DCMAKE_CXX_COMPILER:FILEPATH=${CMAKE_CXX_COMPILER}
   -DCMAKE_C_FLAGS:STRING=${CMAKE_C_FLAGS}
   "-DCMAKE_CXX_FLAGS:STRING=${CMAKE_CXX_FLAGS} ${MITK_CXX14_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}
 )
 
 set(DCMTK_CMAKE_DEBUG_POSTFIX )
 
 # python libraries wont work with it
 if(NOT MITK_USE_Python)
   list(APPEND ep_common_args -DCMAKE_DEBUG_POSTFIX:STRING=d)
   set(DCMTK_CMAKE_DEBUG_POSTFIX d)
 endif()
 
 set(ep_common_cache_args
 )
 
 set(ep_common_cache_default_args
   "-DCMAKE_PREFIX_PATH:PATH=<INSTALL_DIR>;${CMAKE_PREFIX_PATH}"
   "-DCMAKE_INCLUDE_PATH:PATH=${CMAKE_INCLUDE_PATH}"
   "-DCMAKE_LIBRARY_PATH:PATH=${CMAKE_LIBRARY_PATH}"
 )
 
 # 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})
   if(EXISTS ${CMAKE_SOURCE_DIR}/CMakeExternals/${p}.cmake)
     include(CMakeExternals/${p}.cmake)
   else()
     foreach(MITK_EXTENSION_DIR ${MITK_EXTENSION_DIRS})
       get_filename_component(MITK_EXTENSION_DIR ${MITK_EXTENSION_DIR} ABSOLUTE)
       set(MITK_CMAKE_EXTERNALS_EXTENSION_DIR ${MITK_EXTENSION_DIR}/CMakeExternals)
       if(EXISTS ${MITK_CMAKE_EXTERNALS_EXTENSION_DIR}/${p}.cmake)
         include(${MITK_CMAKE_EXTERNALS_EXTENSION_DIR}/${p}.cmake)
         break()
       endif()
     endforeach()
   endif()
 
   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()
 if (SWIG_EXECUTABLE)
   list(APPEND mitk_superbuild_ep_args -DSWIG_EXECUTABLE=${SWIG_EXECUTABLE})
 endif()
 
 #-----------------------------------------------------------------------------
 # 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_EXAMPLES
 
   MITK_USE_Qt5
   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}
       )
 endif()
 
 if(Eigen_INCLUDE_DIR)
     list(APPEND mitk_optional_cache_args
       -DEigen_INCLUDE_DIR:PATH=${Eigen_INCLUDE_DIR}
     )
 endif()
 
 # Optional pass through of Doxygen
 if(DOXYGEN_EXECUTABLE)
   list(APPEND mitk_optional_cache_args
        -DDOXYGEN_EXECUTABLE:FILEPATH=${DOXYGEN_EXECUTABLE}
   )
 endif()
 
 set(proj MITK-Configure)
 
 ExternalProject_Add(${proj}
   LIST_SEPARATOR ${sep}
   DOWNLOAD_COMMAND ""
   CMAKE_GENERATOR ${gen}
+  CMAKE_GENERATOR_PLATFORM ${gen_platform}
   CMAKE_CACHE_ARGS
     # --------------- Build options ----------------
     -DCMAKE_INSTALL_PREFIX:PATH=${CMAKE_INSTALL_PREFIX}
     -DCMAKE_BUILD_TYPE:STRING=${CMAKE_BUILD_TYPE}
     "-DCMAKE_PREFIX_PATH:PATH=${ep_prefix};${CMAKE_PREFIX_PATH}"
     "-DCMAKE_LIBRARY_PATH:PATH=${CMAKE_LIBRARY_PATH}"
     "-DCMAKE_INCLUDE_PATH:PATH=${CMAKE_INCLUDE_PATH}"
     # --------------- Compile options ----------------
     -DCMAKE_CXX_EXTENSIONS:STRING=${CMAKE_CXX_EXTENSIONS}
     -DCMAKE_CXX_STANDARD:STRING=${CMAKE_CXX_STANDARD}
     -DCMAKE_CXX_STANDARD_REQUIRED:BOOL=${CMAKE_CXX_STANDARD_REQUIRED}
     -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 ---------------
     -DCMAKE_LIBRARY_PATH:PATH=${CMAKE_LIBRARY_PATH}
     -DCMAKE_INCLUDE_PATH:PATH=${CMAKE_INCLUDE_PATH}
     -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}
     -DMITK_EXTENSION_DIRS:STRING=${MITK_EXTENSION_DIRS}
     -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}
     -DDCMTK_CMAKE_DEBUG_POSTFIX:STRING=${DCMTK_CMAKE_DEBUG_POSTFIX}
     -DBOOST_ROOT:PATH=${BOOST_ROOT}
     -DBOOST_LIBRARYDIR:PATH=${BOOST_LIBRARYDIR}
     -DMITK_USE_Boost_LIBRARIES:STRING=${MITK_USE_Boost_LIBRARIES}
     -DQt5_DIR:PATH=${Qt5_DIR}
   CMAKE_ARGS
     ${mitk_initial_cache_arg}
     ${MAC_OSX_ARCHITECTURE_ARGS}
     ${mitk_superbuild_ep_args}
   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
 )