diff --git a/CMake/Whitelists/Wrapping.cmake b/CMake/Whitelists/Wrapping.cmake
new file mode 100644
index 0000000000..6bfa892451
--- /dev/null
+++ b/CMake/Whitelists/Wrapping.cmake
@@ -0,0 +1,8 @@
+set(enabled_modules
+  Core
+  CppMicroServices
+)
+
+set(enabled_plugins
+  ""
+)
\ No newline at end of file
diff --git a/CMake/configure_file_build_time.cmake b/CMake/configure_file_build_time.cmake
deleted file mode 100644
index cf1a18002b..0000000000
--- a/CMake/configure_file_build_time.cmake
+++ /dev/null
@@ -1 +0,0 @@
-configure_file( "${CONFIGUREBUILDTIME_filename}" "${CONFIGUREBUILDTIME_out_filename}" )
diff --git a/CMake/mitkSWIGConfigurePythonfileBuildtime.cmake b/CMake/mitkSWIGConfigurePythonfileBuildtime.cmake
new file mode 100644
index 0000000000..87391853f4
--- /dev/null
+++ b/CMake/mitkSWIGConfigurePythonfileBuildtime.cmake
@@ -0,0 +1,19 @@
+INCLUDE(GetPrerequisites)
+
+#file(GLOB_RECURSE TARGET_LIBRARY_FILE ${MITK_CMAKE_RUNTIME_OUTPUT_DIRECTORY}/*/${MITK_BINARY_MODULE})
+find_file(TARGET_LIBRARY_FILE "${MITK_BINARY_MODULE}"
+    ${MITK_CMAKE_RUNTIME_OUTPUT_DIRECTORY}/../lib/Release 
+    ${MITK_CMAKE_RUNTIME_OUTPUT_DIRECTORY}/../lib  
+    ${MITK_CMAKE_RUNTIME_OUTPUT_DIRECTORY}/..
+    ${MITK_CMAKE_RUNTIME_OUTPUT_DIRECTORY}
+    ${MITK_CMAKE_RUNTIME_OUTPUT_DIRECTORY}/Release)
+get_filename_component(TARGET_LIBRARY_DIR ${TARGET_LIBRARY_FILE} DIRECTORY )
+
+#mitkFunctionGetLibrarySearchPaths(MITK_RUNTIME_PATH release)
+list(APPEND MITK_RUNTIME_PATH
+      "${TARGET_LIBRARY_DIR}")
+list(REMOVE_DUPLICATES MITK_RUNTIME_PATH)
+
+get_prerequisites(${TARGET_LIBRARY_FILE} PYTHON_LIB_DEPENDENCIES 1 1 "" "${MITK_RUNTIME_PATH}")
+
+configure_file( "${CONFIGUREBUILDTIME_filename}" "${CONFIGUREBUILDTIME_out_filename}" )
diff --git a/SuperBuild.cmake b/SuperBuild.cmake
index a9ddf083e7..09c8074a55 100644
--- a/SuperBuild.cmake
+++ b/SuperBuild.cmake
@@ -1,442 +1,445 @@
 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)
 
   # 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()
 
 #-----------------------------------------------------------------------------
 # 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()
 
 # 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})
   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()
+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_Qt5_WebEngine
   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(Eigen_INCLUDE_DIR)
     list(APPEND mitk_optional_cache_args
       -DEigen_INCLUDE_DIR:PATH=${Eigen_INCLUDE_DIR}
     )
 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}
     "-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_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}
   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
 )
 
diff --git a/Wrapping/Python/LegacyPackaging.cmake b/Wrapping/Python/LegacyPackaging.cmake
index e9c0c80ade..2c7b214824 100644
--- a/Wrapping/Python/LegacyPackaging.cmake
+++ b/Wrapping/Python/LegacyPackaging.cmake
@@ -1,106 +1,111 @@
 if ( SimpleITK_DOC_FILES )
   # create a python list for the import documents to include in
   # packaging
 
   # specially handle the first element
   list( GET SimpleITK_DOC_FILES 0 d )
   file(TO_NATIVE_PATH "${d}" d )
   set( SimpleITK_DOC_FILES_AS_LIST "[r'${d}'")
   set( _doc_list "${SimpleITK_DOC_FILES}" )
   list( REMOVE_AT _doc_list 0 )
 
   foreach( d ${_doc_list} )
     file(TO_NATIVE_PATH "${d}" d )
     set( SimpleITK_DOC_FILES_AS_LIST "${SimpleITK_DOC_FILES_AS_LIST},r'${d}'")
   endforeach()
   set( SimpleITK_DOC_FILES_AS_LIST "${SimpleITK_DOC_FILES_AS_LIST}]")
 
 endif()
 
 # Step 1:
 # Do initial configuration of setup.py with variable a available
 # at configuration time.
 set(MITK_BINARY_MODULE "@MITK_BINARY_MODULE@")
+set(MITK_RUNTIME_PATH "@MITK_RUNTIME_PATH@")
+set(PYTHON_LIB_DEPENDENCIES "@PYTHON_LIB_DEPENDENCIES@")
 configure_file(
   "${CMAKE_CURRENT_SOURCE_DIR}/Packaging/setup.py.in"
   "${CMAKE_CURRENT_BINARY_DIR}/Packaging/setup.py.in" )
 set(MITK_BINARY_MODULE)
 
 # Step 2:
 # Do file configuration during compilation with generator expressions
+mitkFunctionGetLibrarySearchPaths(MITK_RUNTIME_PATH release)
 add_custom_command(TARGET ${SWIG_MODULE_PythonMITK_REAL_NAME}
   POST_BUILD
   WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
   COMMAND ${CMAKE_COMMAND}
     "-DMITK_BINARY_MODULE=$<TARGET_FILE_NAME:${SWIG_MODULE_PythonMITK_REAL_NAME}>"
+    "-DMITK_CMAKE_RUNTIME_OUTPUT_DIRECTORY=${MITK_CMAKE_RUNTIME_OUTPUT_DIRECTORY}"
+    "-DMITK_RUNTIME_PATH=${MITK_RUNTIME_PATH}"
     "-DCONFIGUREBUILDTIME_filename=${CMAKE_CURRENT_BINARY_DIR}/Packaging/setup.py.in"
     "-DCONFIGUREBUILDTIME_out_filename=${CMAKE_CURRENT_BINARY_DIR}/Packaging/setup.py"
-    -P "${MITK_SOURCE_DIR}/CMake/configure_file_build_time.cmake"
+    -P "${MITK_SOURCE_DIR}/CMake/mitkSWIGConfigurePythonfileBuildtime.cmake"
   COMMENT "Generating setup.py..."
   )
 
 configure_file(
   "${CMAKE_CURRENT_SOURCE_DIR}/Packaging/__init__.py"
   "${CMAKE_CURRENT_BINARY_DIR}/__init__.py"
   COPYONLY )
 
 # Hopefully being able to turn this option on at some point in future.
 option(MITK_PYTHON_USE_VIRTUALENV "Create a Python Virtual Environment for testing." OFF)
 mark_as_advanced(MITK_PYTHON_USE_VIRTUALENV)
 
 set(VIRTUAL_PYTHON_EXECUTABLE ${PYTHON_EXECUTABLE})
 if (MITK_PYTHON_USE_VIRTUALENV)
 
   # Executable to setup a new Python virtual environment
   find_package( PythonVirtualEnv REQUIRED )
 
   sitk_enforce_forbid_downloads( MITK_PYTHON_USE_VIRTUALENV )
 
   if (SimpleITK_PYTHON_WHEEL AND PYTHON_VIRTUALENV_VERSION_STRING VERSION_LESS "13")
     message(SEND_ERROR "In sufficient version of virutalenv for \
       building wheels. Require virtualenv>=13.0.")
   endif()
 
   #
   # Setup Python Virtual Environment for testing and packaging
   #
   set( PythonVirtualenvHome "${${CMAKE_PROJECT_NAME}_BINARY_DIR}/Testing/Installation/PythonVirtualenv" )
 
   # virtualenv places the python executable in different
   # locations. Also note than on windows installations where python is
   # installed only for a single user the may be a missing dll issue.
   if( WIN32 )
     set( VIRTUAL_PYTHON_EXECUTABLE
       "${PythonVirtualenvHome}/Scripts/python")
   else( )
     set( VIRTUAL_PYTHON_EXECUTABLE "${PythonVirtualenvHome}/bin/python" )
   endif()
   set(SimpleITK_PYTHON_TEST_EXECUTABLE "${VIRTUAL_PYTHON_EXECUTABLE}"
     CACHE INTERNAL "Python executable for testing." FORCE )
 
   # configure a scripts which creates the virtualenv and installs numpy
   configure_file(
     "${CMAKE_CURRENT_SOURCE_DIR}/PythonVirtualEnvInstall.cmake.in"
     "${CMAKE_CURRENT_BINARY_DIR}/PythonVirtualEnvInstall.cmake"
     @ONLY )
 
   set( PythonVirtualEnv_ALL "" )
   if ( BUILD_TESTING )
     set( PythonVirtualEnv_ALL "ALL" )
   endif()
 
   add_custom_target( PythonVirtualEnv ${PythonVirtualEnv_ALL}
     DEPENDS "${VIRTUAL_PYTHON_EXECUTABLE}"
     SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/PythonVirtualEnvInstall.cmake.in )
 
   add_custom_command( OUTPUT "${VIRTUAL_PYTHON_EXECUTABLE}"
     COMMAND ${CMAKE_COMMAND} -P "${CMAKE_CURRENT_BINARY_DIR}/PythonVirtualEnvInstall.cmake"
     DEPENDS
     "${SWIG_MODULE_SimpleITKPython_TARGET_NAME}"
     "${CMAKE_CURRENT_BINARY_DIR}/PythonVirtualEnvInstall.cmake"
     COMMENT "Creating python virtual enviroment..."
     )
 endif()
 
 # Packaging for distribution
 add_subdirectory(dist)
diff --git a/Wrapping/Python/Packaging/setup.py.in b/Wrapping/Python/Packaging/setup.py.in
index 492aa95fbc..12ff67d4ae 100644
--- a/Wrapping/Python/Packaging/setup.py.in
+++ b/Wrapping/Python/Packaging/setup.py.in
@@ -1,107 +1,126 @@
 import sys
 import os
+import glob
 
 try:
     from setuptools import setup, Extension
     from setuptools.command.build_ext import build_ext as _build_ext
 except ImportError:
     from distutils.core import setup, Extension
     from distutils.command.build_ext import build_ext as _build_ext
 
 import re
 
 doc_files = ""
+dependency_paths = "@MITK_RUNTIME_PATH@"
+dependency_files = "@PYTHON_LIB_DEPENDENCIES@"
 
 def get_pep386version():
     """This method examines the SimpleITK's CMake version variables to make a pep 386 compliant version string when building a version indented for distribution."""
-    sitkMAJOR = "@SimpleITK_VERSION_MAJOR@"
-    sitkMINOR = "@SimpleITK_VERSION_MINOR@"
-    sitkPATCH = "@SimpleITK_VERSION_PATCH@"
-    sitkTWEAK = "@SimpleITK_VERSION_TWEAK@"
-    sitkRC    = "@SimpleITK_VERSION_RC@"
-    sitkPOST  = "@SimpleITK_VERSION_POST@"
-    sitkDEV   = "@SimpleITK_VERSION_DEV@"
-    sitkHASH  = "@SimpleITK_VERSION_HASH@"
+    sitkMAJOR = "@MITK_VERSION_MAJOR@"
+    sitkMINOR = "@MITK_VERSION_MINOR@"
+    sitkPATCH = "@MITK_VERSION_PATCH@"
+    sitkTWEAK = "@MITK_VERSION_TWEAK@"
+    sitkRC    = "@MITK_VERSION_RC@"
+    sitkPOST  = "@MITK_VERSION_POST@"
+    sitkDEV   = "@MITK_VERSION_DEV@"
+    sitkHASH  = "@MITK_VERSION_HASH@"
 
 
     version = sitkMAJOR+"."+sitkMINOR
 
     if sitkPATCH:
         version += "."+sitkPATCH
         if sitkTWEAK:
             version += "."+sitkTWEAK
 
     if  sitkRC:
         version += sitkRC
 
     if sitkPOST:
         version += ".post"+sitkPOST
     elif sitkDEV:
         version += ".dev"+sitkDEV
 
     # Local Version Identifier
     if sitkHASH and not "@SimpleITK_BUILD_DISTRIBUTE@" in ['1', 'ON']:
         version += "+g"+sitkHASH
 
     return version
 
 class build_ext(_build_ext):
     """ Override standard command class to build an extension, to
     simply copy an existing compiled library into the packaging
     directory structure.
     """
 
     def build_extension(self, ext):
         """
         """
         from distutils.errors import DistutilsSetupError
-
+        
         sources = ext.sources
         if sources is None or not len(sources) == 1:
             raise DistutilsSetupError( "Expected only one compiled library." )
 
         expected_ext_filename = os.path.split(self.get_ext_filename(ext.name))[1]
 
         ext_file = self.get_ext_fullpath(ext.name)
 
         abs_sources = list( map(os.path.abspath, sources) )
 
-        self.copy_file(abs_sources[0], ext_file)
+        module_name=ext.name.split(".")[0]
+        placeholder = self.get_ext_filename("placeholder")
+        
+        for current_path in dependency_paths.split(";"):
+           for pyd_file in glob.glob(os.path.join(current_path,"*.pyd")):
+              if sources[0] in pyd_file:
+                 self.copy_file(pyd_file, ext_file)
+           for dll_file in glob.glob(os.path.join(current_path,"*.dll")):
+              if "Qt" in dll_file:
+                continue
+              dll_basename=os.path.basename(dll_file)
+              if dll_basename not in dependency_files:
+                continue
+              dll_target= self.get_ext_fullpath(module_name+".placeholder")
+              self.copy_file(dll_file,dll_target.replace(placeholder,dll_basename))        
+        
+        #self.copy_file(abs_sources[0], ext_file)
 
 
 setup(
     name = 'PythonMITK',
     version = get_pep386version(),
     author = 'Medical Image Computing, DKFZ Heidelberg',
     author_email = 'm.goetz@dkfz-heidelberg.de',
     ext_modules=[Extension('PythonMITK._PythonMITK', [r'@MITK_BINARY_MODULE@'])],
     packages= ['PythonMITK'],
     package_dir = {'PythonMITK':r'@MITK_PYTHON_PACKAGE_DIR@'},
     download_url = r'https://www.itk.org/SimpleITKDoxygen/html/PyDownloadPage.html',
     platforms = [],
     description = r'SimpleITK is a simplified interface to the Insight Toolkit (ITK) for image registration and segmentation',
     long_description  = 'SimpleITK provides an abstraction layer to ITK that enables developers \
                          and users to access the powerful features of the InsightToolkit in an easy \
                          to use manner for biomedical image analysis.',
     classifiers=[
         "License :: OSI Approved :: Apache Software License",
         "Programming Language :: Python",
         "Programming Language :: C++",
         "Development Status :: 5 - Production/Stable",
         "Intended Audience :: Education",
         "Intended Audience :: Healthcare Industry",
         "Intended Audience :: Science/Research",
         "Topic :: Scientific/Engineering",
         "Topic :: Scientific/Engineering :: Medical Science Apps.",
         "Topic :: Scientific/Engineering :: Information Analysis",
         "Topic :: Software Development :: Libraries",
         "Operating System :: Microsoft :: Windows",
         "Operating System :: POSIX",
         "Operating System :: Unix",
         "Operating System :: MacOS"
         ],
     license='Apache',
     keywords = 'SimpleITK ITK InsightToolkit segmentation registration',
     url = r'http://simpleitk.org/',
     cmdclass={'build_ext':build_ext}
     )
diff --git a/Wrapping/Python/dist/CMakeLists.txt b/Wrapping/Python/dist/CMakeLists.txt
index ac404601f9..e7ffa6ae16 100644
--- a/Wrapping/Python/dist/CMakeLists.txt
+++ b/Wrapping/Python/dist/CMakeLists.txt
@@ -1,43 +1,40 @@
 #
 # Packaging
 #
 if( MITK_PYTHON_EGG OR MITK_PYTHON_WHEEL )
   if( NOT MITK_PYTHON_USE_VIRTUALENV )
     message( STATUS "Not using SimpleITK's virtualenv for distribution!\n
 Using unknown versions of pip, setuptools and/or wheel packages/" )
   endif()
 
   set(bdist_setup "${MITK_Python_BINARY_DIR}/Packaging/setup.py")
   set(bdist_commands "")
 
   if( MITK_PYTHON_EGG )
     set(bdist_commands "bdist_egg")
   endif()
 
   if( MITK_PYTHON_WHEEL )
     set(bdist_commands ${bdist_commands} "bdist_wheel")
   endif()
 
   set( MITK_PYTHON_PLAT_NAME "" CACHE STRING
     "Optional value passed to setup.py with the '--plat-name' argument")
 
   if( NOT "${MITK_PYTHON_PLAT_NAME}" STREQUAL "" )
     set(bdist_commands ${bdist_commands} "--plat-name" "${MITK_PYTHON_PLAT_NAME}")
   endif()
 
-  message(WARNING ${VIRTUAL_PYTHON_EXECUTABLE})
-  message(WARNING ${bdist_setup})
-  message(WARNING ${bdist_commands})
   add_custom_target( dist.Python
     ${VIRTUAL_PYTHON_EXECUTABLE} ${bdist_setup} ${bdist_commands}
     WORKING_DIRECTORY ${MITK_Python_BINARY_DIR}
     DEPENDS ${SWIG_MODULE_PythonMITK_REAL_NAME}
     COMMENT "Creating Python binary distribution" )
 
   if( MITK_PYTHON_USE_VIRTUALENV )
     add_dependencies( dist.Python PythonVirtualEnv)
   endif()
   add_dependencies( dist dist.Python )
 elseif()
   message( STATUS "Not creating dist.Python target since SimpleITK_FORBID_DOWNLOADS is enabled" )
 endif()