diff --git a/CMake/mitkFunctionInstallPython.cmake b/CMake/mitkFunctionInstallPython.cmake
index 3867544f1a..057582615b 100644
--- a/CMake/mitkFunctionInstallPython.cmake
+++ b/CMake/mitkFunctionInstallPython.cmake
@@ -1,134 +1,144 @@
-
+#! This CMake function install the python runtime with
+#! all python related libraries and toolkits. Py files are
+#! searched one by one with a globbing expression to generate a list used
+#! by the mac and NSIS installer.
+#!
+#! params:
+#!  _python_libs Returns a list of the installed libraries. Used to fixup the bundle.
+#!  _python_dirs Returns a list with the directories containig the dependencies
+#!               to the installed libs.
+#! _app_bundle App bundle name in case of a Apple bundle.
+#!
 function(mitkFunctionInstallPython _python_libs _python_dirs _app_bundle)
 
   set(_destination bin)
   if(APPLE)
     set(_destination ${_app_bundle})
   endif()
 
   if(UNIX)
     # apple and linux only supports .so as loadable extension
     set(PYTHON_LIB_SUFFIX .so)
   else(WIN32)
     # windows only supports pyd as loadable extension
     set(PYTHON_LIB_SUFFIX .pyd)
   endif()
 
   # SimpleITK
   if(MITK_USE_SimpleITK)
     install(FILES "${SimpleITK_DIR}/Wrapping/SimpleITK.py"
                   DESTINATION ${_destination}/Python/SimpleITK )
     install(FILES "${SimpleITK_DIR}/Wrapping/__init__.py"
                   DESTINATION ${_destination}/Python/SimpleITK )
     install(FILES "${SimpleITK_DIR}/Wrapping/_SimpleITK${PYTHON_LIB_SUFFIX}"
                   DESTINATION ${_destination}/Python/SimpleITK )
     if(UNIX AND NOT APPLE)
         install(CODE "file(RPATH_REMOVE
                     FILE \"\${CMAKE_INSTALL_PREFIX}/bin/Python/SimpleITK/_SimpleITK${PYTHON_LIB_SUFFIX}\")")
     endif()
 
     list(APPEND _python_libs "Python/SimpleITK/_SimpleITK${PYTHON_LIB_SUFFIX}")
     list(APPEND _python_dirs "${SimpleITK_DIR}/lib")
   endif()
 
   # install OpenCV python wrapping
   if(MITK_USE_OpenCV)
     list(APPEND _python_libs "cv2${PYTHON_LIB_SUFFIX}")
 
     if(UNIX)
       install(FILES "${OpenCV_DIR}/lib/cv2${PYTHON_LIB_SUFFIX}" DESTINATION ${_destination})
     else()
       install(FILES "${OpenCV_DIR}/lib/Release/cv2${PYTHON_LIB_SUFFIX}" DESTINATION ${_destination})
     endif()
 
     if(UNIX AND NOT APPLE)
       install(CODE "file(RPATH_REMOVE
                          FILE \"\${CMAKE_INSTALL_PREFIX}/bin/cv2${CMAKE_SHARED_LIBRARY_SUFFIX}\")")
     endif()
 
     list(APPEND _python_dirs "${OpenCV_DIR}/lib")
   endif()
 
   # install VTK python wrapping
   find_package(VTK REQUIRED)
 
   set(_VTK_PYTHON_TARGETS )
 
   # find all vtk python wrapped targets
   foreach(_lib ${VTK_LIBRARIES})
     # exclude system libs
     if(${_lib} MATCHES "^vtk.+")
       # use only python wrapped modules ( targets end with PythonD )
       if(TARGET ${_lib}PythonD)
         list(APPEND _VTK_PYTHON_TARGETS ${_lib}Python)
       endif()
     endif()
   endforeach()
 
   # install the python modules and loaders
   foreach(_target ${_VTK_PYTHON_TARGETS})
     # get the properties of the python wrapped target
     if( CMAKE_BUILD_TYPE STREQUAL "Debug")
       get_target_property(_target_lib   "${_target}D" IMPORTED_LOCATION_DEBUG)
     else()
       get_target_property(_target_lib "${_target}D" IMPORTED_LOCATION_RELEASE)
     endif()
     get_filename_component(_filepath "${_target_lib}" PATH)
 
     install(FILES "${_filepath}/${_target}${PYTHON_LIB_SUFFIX}" DESTINATION ${_destination})
 
     if(UNIX AND NOT APPLE )
       install(CODE "file(RPATH_REMOVE
                     FILE \"\${CMAKE_INSTALL_PREFIX}/bin/${_target}${PYTHON_LIB_SUFFIX}\")")
     endif()
     list(APPEND _python_libs "${_target}${PYTHON_LIB_SUFFIX}")
   endforeach()
 
   # install vtk python. This folder contains all *.py files for VTK module loading.
   # glob through all files, NSIS can't use directories
   file(GLOB_RECURSE item RELATIVE "${VTK_DIR}/Wrapping/Python/vtk" "${VTK_DIR}/Wrapping/Python/vtk/*.py")
   foreach(f ${item})
     get_filename_component(_filepath "${f}" PATH)
     install(FILES "${VTK_DIR}/Wrapping/Python/vtk/${f}" DESTINATION ${_destination}/Python/vtk/${_filepath})
   endforeach()
 
   list(APPEND _python_dirs "${VTK_DIR}/lib")
 
   # install the python runtime from the superbuild
   if(NOT MITK_USE_SYSTEM_PYTHON)
     if(UNIX)
       set(_python_runtime_dir lib/python${PYTHON_VERSION_MAJOR}.${PYTHON_VERSION_MINOR})
       list(APPEND _python_dirs "${Python_DIR}/lib")
     else() #WIN32
       set(_python_runtime_dir Lib)
       list(APPEND _python_dirs "${Python_DIR}/libs")
       list(APPEND _python_dirs "${Python_DIR}/bin")
     endif()
 
     file(GLOB_RECURSE item RELATIVE "${Python_DIR}/${_python_runtime_dir}" "${Python_DIR}/${_python_runtime_dir}/*")
     foreach(f ${item})
       get_filename_component(_filepath "${f}" PATH)
       install(FILES "${Python_DIR}/${_python_runtime_dir}/${f}" DESTINATION ${_destination}/Python/${_python_runtime_dir}/${_filepath})
     endforeach()
 
     file(GLOB_RECURSE item RELATIVE "${Python_DIR}/include" "${Python_DIR}/include/*")
     foreach(f ${item})
       get_filename_component(_filepath "${f}" PATH)
       install(FILES "${Python_DIR}/include/${f}" DESTINATION ${_destination}/Python/include/${_filepath})
     endforeach()
 
     # Numpy is always build in an own runtime
     if(Numpy_DIR)
       # glob through all files, NSIS can't use directories
       file(GLOB_RECURSE item RELATIVE "${Numpy_DIR}/numpy" "${Numpy_DIR}/numpy/*")
       foreach(f ${item})
         get_filename_component(_filepath "${f}" PATH)
         install(FILES "${Numpy_DIR}/numpy/${f}" DESTINATION ${_destination}/Python/numpy/${_filepath})
       endforeach()
     endif()
   endif()
 
   list(REMOVE_DUPLICATES _python_dirs)
 
 endfunction()
 
diff --git a/CMake/mitkMacroInstall.cmake b/CMake/mitkMacroInstall.cmake
index 71b11c97cf..8385998d6b 100644
--- a/CMake/mitkMacroInstall.cmake
+++ b/CMake/mitkMacroInstall.cmake
@@ -1,192 +1,192 @@
 #
 # MITK specific install macro
 #
 # On Mac everything is installed for each bundle listed in MACOSX_BUNDLE_NAMES
 # by replacing the DESTINATION parameter. Everything else is passed to the CMake INSTALL command
 #
 # Usage: MITK_INSTALL( )
 #
 macro(MITK_INSTALL)
 
   set(ARGS ${ARGN})
 
   set(install_directories "")
   list(FIND ARGS DESTINATION _destination_index)
   # set(_install_DESTINATION "")
   if(_destination_index GREATER -1)
     message(SEND_ERROR "MITK_INSTALL macro must not be called with a DESTINATION parameter.")
     ### This code was a try to replace a given DESTINATION
     #math(EXPR _destination_index ${_destination_index} + 1)
     #list(GET ARGS ${_destination_index} _install_DESTINATION)
     #string(REGEX REPLACE ^bin "" _install_DESTINATION ${_install_DESTINATION})
   else()
     if(NOT MACOSX_BUNDLE_NAMES)
       install(${ARGS} DESTINATION bin)
     else()
       foreach(bundle_name ${MACOSX_BUNDLE_NAMES})
         install(${ARGS} DESTINATION ${bundle_name}.app/Contents/MacOS/${_install_DESTINATION})
       endforeach()
     endif()
   endif()
 
 endmacro()
 
 # Fix _target_location
 # This is used in several install macros
 macro(_fixup_target)
 
   if(NOT intermediate_dir)
     if(WIN32 AND NOT MINGW)
       set(intermediate_dir Release)
     else()
       set(intermediate_dir .)
     endif()
   endif()
 
   set(_python_libs )
   set(_python_dirs )
   if(MITK_USE_Python)
     include(mitkFunctionInstallPython)
-    mitkFunctionInstallPython(_python_libs _python_dirs ${_bundle_dest_dir})
+    mitkFunctionInstallPython(_python_libs _python_dirs "${_bundle_dest_dir}")
   endif()
 
   mitkFunctionGetLibrarySearchPaths(_search_paths ${intermediate_dir})
 
   install(CODE "
 
     set(_bundle_dest_dir \"${_bundle_dest_dir}\")
     if(_bundle_dest_dir)
       set(_bin_path \"\${CMAKE_INSTALL_PREFIX}/\${_bundle_dest_dir}\")
     else()
       set(_bin_path \"\${CMAKE_INSTALL_PREFIX}/bin\")
     endif()
 
     macro(gp_item_default_embedded_path_override item default_embedded_path_var)
       get_filename_component(_item_name \"\${item}\" NAME)
       get_filename_component(_item_path \"\${item}\" PATH)
 
       # We have to fix all path references to build trees for plugins
 
       if(NOT _item_path MATCHES \"\${CMAKE_INSTALL_PREFIX}/${_bundle_dest_dir}\")
         # item with relative path or embedded path pointing to some build dir
         set(full_path \"full_path-NOTFOUND\")
         file(GLOB_RECURSE full_path \${CMAKE_INSTALL_PREFIX}/${_bundle_dest_dir}/\${_item_name} )
         list(LENGTH full_path full_path_length)
         if(full_path_length GREATER 1)
           list(GET full_path 0 full_path)
         endif()
         get_filename_component(_item_path \"\${full_path}\" PATH)
       endif()
 
       set(_plugins_path \"\${_bin_path}/plugins\")
 
       if(_item_path STREQUAL _plugins_path
          OR (_item_path MATCHES \"\${_plugins_path}/\" AND _item_name MATCHES \"liborg\") # this is for legacy BlueBerry bundle support
         )
         # Only fix plugins
         message(\"override: \${item}\")
         message(\"found file: \${_item_path}/\${_item_name}\")
         if(APPLE)
           string(REPLACE
                  \${CMAKE_INSTALL_PREFIX}/${_bundle_dest_dir}
                  @executable_path \${default_embedded_path_var} \"\${_item_path}\" )
         else()
           set(\${default_embedded_path_var} \"\${_item_path}\")
         endif()
         message(\"override result: \${\${default_embedded_path_var}}\")
       endif()
     endmacro(gp_item_default_embedded_path_override)
 
     macro(gp_resolved_file_type_override file type)
       if(NOT APPLE)
         get_filename_component(_file_path \"\${file}\" PATH)
         get_filename_component(_file_name \"\${file}\" NAME)
         if(_file_path MATCHES \"^\${CMAKE_INSTALL_PREFIX}\")
           set(\${type} \"local\")
         endif()
         if(_file_name MATCHES gdiplus)
             set(\${type} \"system\")
         endif(_file_name MATCHES gdiplus)
       endif()
     endmacro(gp_resolved_file_type_override)
 
     if(NOT APPLE)
       macro(gp_resolve_item_override context item exepath dirs resolved_item_var resolved_var)
         if(\${item} MATCHES \"blueberry_osgi\")
           get_filename_component(_item_name \${item} NAME)
           set(\${resolved_item_var} \"\${exepath}/plugins/\${_item_name}\")
           set(\${resolved_var} 1)
         endif()
       endmacro()
     endif()
 
     if(\"${_install_GLOB_PLUGINS}\" STREQUAL \"TRUE\")
       set(GLOBBED_PLUGINS )
       set(_bb_osgi_lib \"\${_bin_path}/liborg_blueberry_osgi${CMAKE_SHARED_LIBRARY_SUFFIX}\")
       if(EXISTS \"\${_bb_osgi_lib}\")
         list(APPEND GLOBBED_PLUGINS \"\${_bb_osgi_lib}\")
       endif()
 
       # Iterate over all sub-directories which contain plug-ins
       # (BlueBerry plug-ins, Qt plug-ins, and auto-load modules)
       file(GLOB _children \"\${_bin_path}/*\")
       foreach(_child \${_children})
         if(IS_DIRECTORY \${_child})
           set(_plugins )
           set(_modules )
           file(GLOB_RECURSE _plugins \"\${_child}/*${CMAKE_SHARED_LIBRARY_SUFFIX}\")
           if(_plugins)
             list(APPEND GLOBBED_PLUGINS \${_plugins})
           endif()
           # Now glob for all modules which might have a different extensions.
           # E.g. on MacOS plugins could have a .dylib extension as well as a .so extension
           if(NOT \"${CMAKE_SHARED_MODULE_SUFFIX}\" STREQUAL \"\" AND NOT \"${CMAKE_SHARED_MODULE_SUFFIX}\" STREQUAL \"${CMAKE_SHARED_LIBRARY_SUFFIX}\")
             file(GLOB_RECURSE _modules \"\${_child}/*${CMAKE_SHARED_MODULE_SUFFIX}\")
           endif()
           if(_modules)
             list(APPEND GLOBBED_PLUGINS \${_modules})
           endif()
         endif()
       endforeach()
     endif()
 
     set(PLUGINS )
     foreach(_plugin ${_install_PLUGINS} \${GLOBBED_PLUGINS})
       get_filename_component(_plugin_realpath \${_plugin} REALPATH)
       list(APPEND PLUGINS \${_plugin_realpath})
     endforeach()
 
     foreach(_py_lib ${_python_libs})
       list(APPEND PLUGINS \"\${_bin_path}/\${_py_lib}\")
     endforeach()
 
     if(PLUGINS)
       list(REMOVE_DUPLICATES PLUGINS)
     endif(PLUGINS)
     message(\"globbed plugins: \${PLUGINS}\")
 
     set(CMAKE_MODULE_PATH ${MITK_SOURCE_DIR}/CMake ${CMAKE_MODULE_PATH} )
 
     set(DIRS \"${_search_paths}\")
 
     set(_additional_search_paths ${_install_LIBRARY_DIRS})
     if(_additional_search_paths)
       set(DIRS \"\${DIRS};\${_additional_search_paths}\")
     endif()
     foreach(_plugin \${PLUGINS})
       get_filename_component(_pluginpath \${_plugin} PATH)
       list(APPEND DIRS \"\${_pluginpath}\")
     endforeach(_plugin)
 
     foreach(_dir ${_python_dirs})
       list(APPEND DIRS \"\${_dir}\")
     endforeach()
 
     list(REMOVE_DUPLICATES DIRS)
 
     # use custom version of BundleUtilities
     include(BundleUtilities)
 
     fixup_bundle(\"\${CMAKE_INSTALL_PREFIX}/${_target_location}\" \"\${PLUGINS}\" \"\${DIRS}\")
   ")
 endmacro()
diff --git a/CMakeExternals/PCRE.cmake b/CMakeExternals/PCRE.cmake
index aac94b7852..69dcca017c 100644
--- a/CMakeExternals/PCRE.cmake
+++ b/CMakeExternals/PCRE.cmake
@@ -1,39 +1,36 @@
 #--------------------------------------------------------------------------
 #  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()
   if(NOT PCRE_DIR)
 
     set(proj PCRE)
     set(${proj}_DEPENDENCIES "")
     set(PCRE_TARGET_VERSION 8.35)
     set(PCRE_DOWNLOAD_SOURCE_HASH "ed58bcbe54d3b1d59e9f5415ef45ce1c")
 
-    set(pcre_binary_dir ${CMAKE_CURRENT_BINARY_DIR}/${proj}-build)
-    set(pcre_source_dir ${CMAKE_CURRENT_BINARY_DIR}/${proj}-src)
-    set(pcre_install_dir ${CMAKE_CURRENT_BINARY_DIR}/PCRE-install)
-
-    configure_file(
-      ${MITK_SOURCE_DIR}/CMakeExternals/pcre_configure_step.cmake.in
-      ${CMAKE_CURRENT_BINARY_DIR}/pcre_configure_step.cmake
-      @ONLY)
-
-    set ( pcre_CONFIGURE_COMMAND ${CMAKE_COMMAND} -P ${CMAKE_CURRENT_BINARY_DIR}/pcre_configure_step.cmake )
-
     ExternalProject_add(${proj}
       URL http://midas3.kitware.com/midas/api/rest?method=midas.bitstream.download&checksum=${PCRE_DOWNLOAD_SOURCE_HASH}&name=pcre-${PCRE_TARGET_VERSION}.tar.gz
       URL_MD5 "${PCRE_DOWNLOAD_SOURCE_HASH}"
-      SOURCE_DIR ${pcre_source_dir}
-      BINARY_DIR ${pcre_binary_dir}
-      INSTALL_DIR ${pcre_install_dir}
+      SOURCE_DIR ${CMAKE_CURRENT_BINARY_DIR}/${proj}-src
+      BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR}/${proj}-build
+      INSTALL_DIR ${CMAKE_CURRENT_BINARY_DIR}/${proj}-install
       PREFIX ${proj}-cmake
-      CONFIGURE_COMMAND ${pcre_CONFIGURE_COMMAND}
+      CONFIGURE_COMMAND CC=${CMAKE_C_COMPILER}${CMAKE_C_COMPILER_ARG1}
+                        LDFLAGS=${CMAKE_LINKER_FLAGS} ${CMAKE_LINKER_FLAGS_RELEASE}
+                        CXX=${CMAKE_CXX_COMPILER}${CMAKE_CXX_COMPILER_ARG1}
+                        <SOURCE_DIR>/./configure
+                        --prefix=<INSTALL_DIR>
+                        --disable-shared
       DEPENDS "${${proj}_DEPENDENCIES}"
       )
+
+    set(PCRE_DIR ${CMAKE_CURRENT_BINARY_DIR}/${proj}-install)
+
   else()
     mitkMacroEmptyExternalProject(${proj} "${${proj}_DEPENDENCIES}")
   endif()
 endif()
diff --git a/CMakeExternals/Swig.cmake b/CMakeExternals/Swig.cmake
index f234440a42..80db520e1a 100644
--- a/CMakeExternals/Swig.cmake
+++ b/CMakeExternals/Swig.cmake
@@ -1,70 +1,65 @@
 #------------------------------------------------------------
 # SWIG (Simple Wrapper Interface Generator)
 #-----------------------------------------------------------
 if(MITK_USE_SWIG)
   if(DEFINED Swig_DIR AND NOT EXISTS ${Swig_DIR})
     message(FATAL_ERROR "Swig_DIR variable is defined but corresponds to non-existing directory")
   endif()
 
   if(NOT SWIG_DIR)
     set(SWIG_TARGET_VERSION 3.0.2)
     set(proj Swig)
     set(Swig_DEPENDENCIES )
     set(Swig_DEPENDS )
 
     # binary SWIG for windows
     if(WIN32)
       set(swig_source_dir ${CMAKE_CURRENT_BINARY_DIR}/swigwin-${SWIG_TARGET_VERSION})
 
       # swig.exe available as pre-built binary on Windows:
       ExternalProject_Add(Swig
         URL https://dl.dropboxusercontent.com/u/8367205/ExternalProjects/swigwin-${SWIG_TARGET_VERSION}.zip
         URL_MD5 "3f18de4fc09ab9abb0d3be37c11fbc8f"
         SOURCE_DIR ${CMAKE_CURRENT_BINARY_DIR}/swigwin-${SWIG_TARGET_VERSION}
         CONFIGURE_COMMAND ""
         BUILD_COMMAND ""
         INSTALL_COMMAND ""
         )
 
       set(SWIG_DIR ${CMAKE_CURRENT_BINARY_DIR}/swigwin-${SWIG_TARGET_VERSION}) # path specified as source in ep
       set(SWIG_EXECUTABLE ${CMAKE_CURRENT_BINARY_DIR}/swigwin-${SWIG_TARGET_VERSION}/swig.exe)
 
     else()
 
       list(APPEND Swig_DEPENDENCIES PCRE)
 
       # swig uses bison find it by cmake and pass it down
       find_package(BISON)
       set(BISON_FLAGS "" CACHE STRING "Flags used by bison")
       mark_as_advanced( BISON_FLAGS)
 
-
-      # follow the standard EP_PREFIX locations
-      set(swig_binary_dir ${CMAKE_CURRENT_BINARY_DIR}/${proj}-src)
-      set(swig_source_dir ${CMAKE_CURRENT_BINARY_DIR}/${proj}-src)
-      set(swig_install_dir ${CMAKE_CURRENT_BINARY_DIR}/${proj}-install)
-
-      # configure step
-      configure_file(
-        ${MITK_SOURCE_DIR}/CMakeExternals/swig_configure_step.cmake.in
-        ${CMAKE_CURRENT_BINARY_DIR}/swig_configure_step.cmake
-        @ONLY)
-      set(swig_CONFIGURE_COMMAND ${CMAKE_COMMAND} -P ${CMAKE_CURRENT_BINARY_DIR}/swig_configure_step.cmake)
-
-      ExternalProject_add(Swig
+      ExternalProject_add(${proj}
         URL https://dl.dropboxusercontent.com/u/8367205/ExternalProjects/swig-${SWIG_TARGET_VERSION}.tar.gz
         URL_MD5 "62f9b0d010cef36a13a010dc530d0d41"
-        SOURCE_DIR ${swig_source_dir}
-        INSTALL_DIR ${swig_install_dir}
+        SOURCE_DIR ${CMAKE_CURRENT_BINARY_DIR}/${proj}-src
+        BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR}/${proj}-build
+        INSTALL_DIR ${CMAKE_CURRENT_BINARY_DIR}/${proj}-install
         PREFIX ${proj}-cmake
-        BUILD_IN_SOURCE 1
-        CONFIGURE_COMMAND ${swig_CONFIGURE_COMMAND}
+        CONFIGURE_COMMAND CC=${CMAKE_C_COMPILER}${CMAKE_C_COMPILER_ARG1}
+                          LDFLAGS=${CMAKE_LINKER_FLAGS} ${CMAKE_LINKER_FLAGS_RELEASE}
+                          CXX=${CMAKE_CXX_COMPILER}${CMAKE_CXX_COMPILER_ARG1}
+                          YACC=${BISON_EXECUTABLE}
+                          <SOURCE_DIR>/./configure
+                            --prefix=<INSTALL_DIR>
+                            --with-pcre-prefix=${PCRE_DIR}
+                            --without-octave
+                            --with-python=${PYTHON_EXECUTABLE}
         DEPENDS ${Swig_DEPENDENCIES}
         )
 
-      set(SWIG_DIR ${swig_install_dir}/share/swig/${SWIG_TARGET_VERSION})
-      set(SWIG_EXECUTABLE ${swig_install_dir}/bin/swig)
+      set(SWIG_DIR ${CMAKE_CURRENT_BINARY_DIR}/${proj}-install/share/swig/${SWIG_TARGET_VERSION})
+      set(SWIG_EXECUTABLE ${CMAKE_CURRENT_BINARY_DIR}/${proj}-install/bin/swig)
 
     endif()
   endif(NOT SWIG_DIR)
 endif()
diff --git a/CMakeExternals/pcre_configure_step.cmake.in b/CMakeExternals/pcre_configure_step.cmake.in
deleted file mode 100644
index e01ee1454b..0000000000
--- a/CMakeExternals/pcre_configure_step.cmake.in
+++ /dev/null
@@ -1,23 +0,0 @@
-
-set(ENV{CC} "@CMAKE_C_COMPILER@ @CMAKE_C_COMPILER_ARG1@")
-set(ENV{CFLAGS} "@CMAKE_C_FLAGS@ @CMAKE_C_FLAGS_RELEASE@")
-set(ENV{LDFLAGS} "@CMAKE_LINKER_FLAGS@ @CMAKE_LINKER_FLAGS_RELEASE@")
-
-set(ENV{LIBS} "$ENV{LIBS}")
-
-set(ENV{CPP} "$ENV{CPP}")
-set(ENV{CPPFLAGS} "$ENV{CPPFLAGS}")
-set(ENV{CXXPP} "$ENV{CXXPP}")
-
-set(ENV{CXX} "@CMAKE_CXX_COMPILER@ @CMAKE_CXX_COMPILER_ARG1@")
-set(ENV{CXXFLAGS} "@CMAKE_CXX_FLAGS@ @CMAKE_CXX_FLAGS_RELEASE@")
-
-
-set(ENV{YACC} "@BISON_EXECUTABLE@" )
-set(ENV{YFLAGS} "@BISON_FLAGS@" )
-
-execute_process(
-  COMMAND sh @pcre_source_dir@/configure --prefix=@pcre_install_dir@  --disable-shared
-  WORKING_DIRECTORY @pcre_binary_dir@
-)
-
diff --git a/CMakeExternals/swig_configure_step.cmake.in b/CMakeExternals/swig_configure_step.cmake.in
deleted file mode 100644
index 13708fe173..0000000000
--- a/CMakeExternals/swig_configure_step.cmake.in
+++ /dev/null
@@ -1,24 +0,0 @@
-# Set the important envionment variables
-
-set(ENV{CC} "@CMAKE_C_COMPILER@ @CMAKE_C_COMPILER_ARG1@")
-set(ENV{CFLAGS} "@CMAKE_C_FLAGS@ @CMAKE_C_FLAGS_RELEASE@")
-set(ENV{LDFLAGS} "@CMAKE_LINKER_FLAGS@ @CMAKE_LINKER_FLAGS_RELEASE@")
-
-set(ENV{LIBS} "$ENV{LIBS}")
-set(ENV{CPP} "$ENV{CPP}")
-set(ENV{CPPFLAGS} "$ENV{CPPFLAGS}")
-
-set(ENV{CXX} "@CMAKE_CXX_COMPILER@ @CMAKE_CXX_COMPILER_ARG1@")
-set(ENV{CXXFLAGS} "@CMAKE_CXX_FLAGS@ @CMAKE_CXX_FLAGS_RELEASE@")
-
-set(ENV{YACC} "@BISON_EXECUTABLE@" )
-set(ENV{YFLAGS} "@BISON_FLAGS@" )
-
-execute_process(
-  COMMAND sh @swig_source_dir@/configure
-    --prefix=@swig_install_dir@
-    --with-pcre-prefix=@pcre_install_dir@
-    --without-octave
-    --with-python=@PYTHON_EXECUTABLE@
-  WORKING_DIRECTORY @swig_binary_dir@
-)
diff --git a/Modules/Python/CMakeLists.txt b/Modules/Python/CMakeLists.txt
index 67ab31b50f..ce7157a583 100644
--- a/Modules/Python/CMakeLists.txt
+++ b/Modules/Python/CMakeLists.txt
@@ -1,20 +1,21 @@
 if( MITK_USE_Python )
   if(NOT MITK_USE_SYSTEM_PYTHON)
     add_definitions( -DUSE_MITK_BUILTIN_PYTHON )
+    set(NUMPY_INCLUDE_DIR "${Numpy_DIR}/numpy/core/include")
   endif()
 
   set(OpenCV_DEP )
   if(MITK_USE_OpenCV)
     set(OpenCV_DEP OpenCV)
   endif()
 
   MITK_CREATE_MODULE(
     DEPENDS MitkCore
     EXPORT_DEFINE MITK_PYTHON_EXPORT
     PACKAGE_DEPENDS Qt4|QtGui CTK|CTKScriptingPythonCore+CTKScriptingPythonWidgets PythonLibs VTK|vtkPython+vtkWrappingPythonCore SimpleITK ${OpenCV_DEP}
     INCLUDE_DIRS ${NUMPY_INCLUDE_DIR}
   )
   configure_file(PythonPath.h.in "${CMAKE_CURRENT_BINARY_DIR}/PythonPath.h" @ONLY)
 
   add_subdirectory(Testing)
 endif()