diff --git a/CMakeExternals/Numpy.cmake b/CMakeExternals/Numpy.cmake
index 841d78f831..44dab7165e 100644
--- a/CMakeExternals/Numpy.cmake
+++ b/CMakeExternals/Numpy.cmake
@@ -1,138 +1,143 @@
 
 if( MITK_USE_Python )
 
   option(MITK_USE_NUMPY "Use the numpy python library" OFF)
 
   # always build numpy in this case
   if(NOT MITK_USE_SYSTEM_PYTHON)
     set(MITK_USE_NUMPY ON CACHE BOOL "Use the numpy python library" FORCE)
   endif()
 
   if(MITK_USE_NUMPY)
     # Sanity checks
     if(DEFINED Numpy_DIR AND NOT EXISTS ${Numpy_DIR})
       message(FATAL_ERROR "Numpy_DIR variable is defined but corresponds to non-existing directory")
     endif()
 
     if( NOT DEFINED Numpy_DIR )
       set(proj Numpy)
       set(${proj}_DEPENDENCIES )
       set(Numpy_DEPENDS ${proj})
 
       if(NOT MITK_USE_SYSTEM_PYTHON)
         list(APPEND ${proj}_DEPENDENCIES Python)
       endif()
 
       set(_numpy_env
           "
           set(ENV{F77} \"\")
           set(ENV{F90} \"\")
           set(ENV{FFLAGS} \"\")
           set(ENV{ATLAS} \"None\")
           set(ENV{BLAS} \"None\")
           set(ENV{LAPACK} \"None\")
           set(ENV{MKL} \"None\")
           ")
 
       set(_external_python_project ${CMAKE_BINARY_DIR}/mitkExternalPythonProject.cmake)
       file(WRITE ${_external_python_project}
           "
           ${_numpy_env}
           set(ENV{VS_UNICODE_OUTPUT} \"\")
           set(ENV{CC} \"${CMAKE_C_COMPILER} ${CMAKE_C_COMPILER_ARG1}\")
           set(ENV{CFLAGS} \"${CMAKE_C_FLAGS} ${CMAKE_C_FLAGS_RELEASE}\")
           set(ENV{CXX} \"${CMAKE_CXX_COMPILER} ${CMAKE_CXX_COMPILER_ARG1}\")
           set(ENV{CXXFLAGS} \"${CMAKE_CXX_FLAGS} ${CMAKE_CXX_FLAGS_RELEASE}\")
           set(ENV{LDFLAGS} \"${CMAKE_LINKER_FLAGS} ${CMAKE_LINKER_FLAGS_RELEASE}\")
 
           function(MITK_PYTHON_BUILD_STEP proj step)
              set(_command \${ARGN})
 
              message(\"Running \${proj} \${step}:${PYTHON_EXECUTABLE} \${_command}\")
 
              execute_process(
                 COMMAND ${PYTHON_EXECUTABLE} \${_command}
                 WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/\${proj}-src
                 RESULT_VARIABLE result
                 OUTPUT_VARIABLE output
                 ERROR_VARIABLE error
              )
              set(output_file \"${CMAKE_BINARY_DIR}/\${proj}_\${step}_step_output.txt\")
              file(WRITE \${output_file} \${output})
 
              set(error_file \"${CMAKE_BINARY_DIR}/\${proj}_\${step}_step_error.txt\")
              file(WRITE \${error_file} \${error})
 
              if(NOT \${result} EQUAL 0)
                message(FATAL_ERROR \"Error in: \${proj}: \${error}\")
              endif()
            endfunction()
           ")
       # configure step
       set(_configure_step ${CMAKE_BINARY_DIR}/${proj}_configure_step.cmake)
       file(WRITE ${_configure_step}
          "include(\"${_external_python_project}\")
           file(WRITE \"${CMAKE_BINARY_DIR}/${proj}-src/site.cfg\" \"\")
           MITK_PYTHON_BUILD_STEP(${proj} configure setup.py config)
          ")
 
       # build step
       set(_build_step ${CMAKE_BINARY_DIR}/${proj}_build_step.cmake)
       file(WRITE ${_build_step}
          "include(\"${_external_python_project}\")
           MITK_PYTHON_BUILD_STEP(${proj} build setup.py build --fcompiler=none)
          ")
 
       # install step
       set(NUMPY_CMAKE_INSTALL_DIR )
       if(NOT MITK_USE_SYSTEM_PYTHON)
-        set(_install_dir ${Python_BUILD_DIR})
+        set(_install_dir ${Python_DIR})
         if(WIN32)
           STRING(REPLACE "/" "\\\\" _install_dir ${Python_DIR})
         endif()
       else()
         set(NUMPY_CMAKE_INSTALL_DIR INSTALL_DIR ${CMAKE_BINARY_DIR}/${proj}-install)
         set(_install_dir "${CMAKE_BINARY_DIR}/${proj}-install")
         if(WIN32)
           STRING(REPLACE "/" "\\\\" _install_dir ${CMAKE_BINARY_DIR}/${proj}-install)
         endif()
       endif()
 
       set(_install_step ${CMAKE_BINARY_DIR}/${proj}_install_step.cmake)
       file(WRITE ${_install_step}
          "include(\"${_external_python_project}\")
           MITK_PYTHON_BUILD_STEP(${proj} install setup.py install --prefix=${_install_dir})
          ")
 
       #set(Numpy_URL "https://dl.dropboxusercontent.com/u/8367205/ExternalProjects/numpy-1.6.1.tar.gz")
       #set(Numpy_MD5 "2bce18c08fc4fce461656f0f4dd9103e")
       set(Numpy_URL "https://dl.dropboxusercontent.com/u/8367205/ExternalProjects/numpy-1.4.1.tar.gz")
       set(Numpy_MD5 "5c7b5349dc3161763f7f366ceb96516b")
 
       ExternalProject_Add(${proj}
         URL ${Numpy_URL}
         URL_MD5 ${Numpy_MD5}
         SOURCE_DIR ${proj}-src
         PREFIX ${proj}-cmake
         BUILD_IN_SOURCE 1
         ${NUMPY_CMAKE_INSTALL_DIR}
         CONFIGURE_COMMAND ${CMAKE_COMMAND} -P ${_configure_step}
         BUILD_COMMAND   ${CMAKE_COMMAND} -P ${_build_step}
         INSTALL_COMMAND ${CMAKE_COMMAND} -P ${_install_step}
 
         DEPENDS
           ${${proj}_DEPENDENCIES}
       )
 
       if(WIN32)
         set(Numpy_DIR ${_install_dir}/Lib/site-packages)
       else()
         set(Numpy_DIR ${_install_dir}/lib/python2.7/site-packages)
       endif()
+
       set(NUMPY_INCLUDE_DIR ${Numpy_DIR}/numpy/core/include)
+
+      # add Numpy to the python path
+      set(ENV{PYTHONPATH} "${Numpy_DIR}")
+
     else()
       mitkMacroEmptyExternalProject(${proj} "${proj_DEPENDENCIES}")
     endif()
   endif()
 endif()
 
diff --git a/CMakeExternals/OpenCV.cmake b/CMakeExternals/OpenCV.cmake
index e7da362cb2..5769e2867d 100644
--- a/CMakeExternals/OpenCV.cmake
+++ b/CMakeExternals/OpenCV.cmake
@@ -1,104 +1,97 @@
 #-----------------------------------------------------------------------------
 # 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
     )
 
     if(MITK_USE_Python)
       #message(STATUS "PYTHON_EXECUTABLE: ${PYTHON_EXECUTABLE}")
       #message(STATUS "PYTHON_DEBUG_LIBRARY: ${PYTHON_DEBUG_LIBRARY}")
       #message(STATUS "PYTHON_INCLUDE_DIR: ${PYTHON_INCLUDE_DIR}")
       #message(STATUS "PYTHON_LIBRARY: ${PYTHON_LIBRARY}")
       list(APPEND additional_cmake_args
          -DBUILD_opencv_python: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}
 
          #-DPYTHON_LIBRARIES=${PYTHON_LIBRARY}
          #-DPYTHON_DEBUG_LIBRARIES=${PYTHON_DEBUG_LIBRARIES}
           )
       if(NOT MITK_USE_SYSTEM_PYTHON)
         list(APPEND proj_DEPENDENCIES Python)
-        # set the python home to the correct python runtime.
-        # Else OpenCV will use default system paths during configuration.
-        if(WIN32)
-          set(ENV{PYTHONHOME} "${Python_BUILD_DIR}")
-        else()
-          set(ENV{PYTHONHOME} "${Python_DIR}")
-        endif()
       endif()
       # use the numpy build within mitk
       if(MITK_USE_NUMPY)
         list(APPEND proj_DEPENDENCIES Numpy)
       endif()
     else()
       list(APPEND additional_cmake_args
          -DBUILD_opencv_python: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_QT)
       list(APPEND additional_cmake_args
            -DWITH_QT:BOOL=OFF
            -DWITH_QT_OPENGL:BOOL=OFF
            -DQT_QMAKE_EXECUTABLE:FILEPATH=${QT_QMAKE_EXECUTABLE}
           )
     endif()
 
     set(OpenCV_PATCH_COMMAND ${CMAKE_COMMAND} -DTEMPLATE_FILE:FILEPATH=${MITK_SOURCE_DIR}/CMakeExternals/EmptyFileForPatching.dummy -P ${MITK_SOURCE_DIR}/CMakeExternals/PatchOpenCV-2.4.8.2.cmake)
 
 
     set(opencv_url ${MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL}/OpenCV-2.4.8.2.tar.gz)
     set(opencv_url_md5 07fa7c1d225ea7fe8eeb1270a6b00e69)
 
     ExternalProject_Add(${proj}
       SOURCE_DIR ${CMAKE_BINARY_DIR}/${proj}-src
       BINARY_DIR ${proj}-build
       PREFIX ${proj}-cmake
       URL ${opencv_url}
       URL_MD5 ${opencv_url_md5}
       INSTALL_COMMAND ""
       PATCH_COMMAND ${OpenCV_PATCH_COMMAND}
       CMAKE_GENERATOR ${gen}
       CMAKE_ARGS
         ${ep_common_args}
         -DBUILD_DOCS:BOOL=OFF
         -DBUILD_TESTS:BOOL=OFF
         -DBUILD_EXAMPLES:BOOL=OFF
         -DBUILD_DOXYGEN_DOCS:BOOL=OFF
         -DWITH_CUDA:BOOL=ON
         ${additional_cmake_args}
       DEPENDS ${proj_DEPENDENCIES}
     )
 
     set(OpenCV_DIR ${CMAKE_CURRENT_BINARY_DIR}/${proj}-build)
 
   else()
 
     mitkMacroEmptyExternalProject(${proj} "${proj_DEPENDENCIES}")
 
   endif()
 
 endif()
diff --git a/CMakeExternals/Python.cmake b/CMakeExternals/Python.cmake
index c2bdd1fe52..d7d1eb1b70 100644
--- a/CMakeExternals/Python.cmake
+++ b/CMakeExternals/Python.cmake
@@ -1,161 +1,163 @@
 if( MITK_USE_Python AND NOT MITK_USE_SYSTEM_PYTHON )
 
     # Sanity checks
   if(DEFINED Python_DIR AND NOT EXISTS ${Python_DIR})
     message(FATAL_ERROR "Python_DIR variable is defined but corresponds to non-existing directory")
   endif()
 
   if(NOT DEFINED Python_DIR)
     set(proj Python)
     set(proj_DEPENDENCIES )
     set(Python_DEPENDS ${proj})
 
     set(PYTHON_MAJOR_VERSION 2)
     set(PYTHON_MINOR_VERSION 7)
     set(PYTHON_PATCH_VERSION 3)
 
     set(PYTHON_SOURCE_PACKAGE Python-${PYTHON_MAJOR_VERSION}.${PYTHON_MINOR_VERSION}.${PYTHON_PATCH_VERSION})
     set(PYTHON_SOURCE_DIR  "${CMAKE_BINARY_DIR}/${PYTHON_SOURCE_PACKAGE}")
     # patch the VS compiler config
 
     if(WIN32)
       set(PYTHON_PATCH_COMMAND PATCH_COMMAND ${CMAKE_COMMAND} -DPYTHON_SOURCE_DIR:PATH=${PYTHON_SOURCE_DIR} -P ${CMAKE_CURRENT_LIST_DIR}/Patch${proj}.cmake)
     endif()
 
     # download the source code
     ExternalProject_Add(Python-src
       URL "https://dl.dropboxusercontent.com/u/8367205/ExternalProjects/${PYTHON_SOURCE_PACKAGE}.tgz"
       URL_MD5  "2cf641732ac23b18d139be077bd906cd"
       PREFIX   ${CMAKE_BINARY_DIR}/${PYTHON_SOURCE_PACKAGE}-cmake
       SOURCE_DIR  "${PYTHON_SOURCE_DIR}"
       ${PYTHON_PATCH_COMMAND}
       CONFIGURE_COMMAND ""
       BUILD_COMMAND ""
       INSTALL_COMMAND ""
     )
 
     set(additional_cmake_cache_args )
     list(APPEND additional_cmake_cache_args
         -DBUILTIN_ARRAY:BOOL=ON
         -DBUILTIN_AUDIOOP:BOOL=ON
         -DBUILTIN_BINASCII:BOOL=ON
         -DBUILTIN_BISECT:BOOL=ON
         -DBUILTIN_BSDB:BOOL=ON
         -DBUILTIN_BSSDB:BOOL=ON
         -DBUILTIN_BZ2:BOOL=ON
         -DBUILTIN_CMATH:BOOL=ON
         -DBUILTIN_COLLECTIONS:BOOL=ON
         -DBUILTIN_CODECS_CN:BOOL=ON
         -DBUILTIN_CODECS_HK:BOOL=ON
         -DBUILTIN_CODECS_ISO2022:BOOL=ON
         -DBUILTIN_CODECS_JP:BOOL=ON
         -DBUILTIN_CODECS_KR:BOOL=ON
         -DBUILTIN_CODECS_TW:BOOL=ON
         -DBUILTIN_CPICKLE:BOOL=ON
         -DBUILTIN_CRYPT:BOOL=ON
         -DBUILTIN_CSTRINGIO:BOOL=ON
         -DBUILTIN_CSV:BOOL=ON
         -DBUILTIN_CTYPES:BOOL=OFF
         #-DBUILTIN_CTYPES_TEST:BOOL=OFF
         #-DBUILTIN_CURSES:BOOL=ON
         -DBUILTIN_DATETIME:BOOL=ON
         -DBUILTIN_DBM:BOOL=ON
         -DBUILTIN_ELEMENTTREE:BOOL=ON
         -DBUILTIN_FCNTL:BOOL=ON
         -DBUILTIN_FUNCTOOLS:BOOL=ON
         -DBUILTIN_FUTURE_BUILTINS:BOOL=ON
         -DBULTIN_GDBM:BOOL=ON
         -DBUILTIN_GRP:BOOL=ON
         -DBUILTIN_HASHLIB:BOOL=ON
         -DBUILTIN_HEAPQ:BOOL=ON
         -DBUILTIN_HOTSHOT:BOOL=ON
         -DBUILTIN_IO:BOOL=ON
         -DBUILTIN_ITERTOOLS:BOOL=ON
         -DBUILTIN_JSON:BOOL=ON
         -DBUILTIN_LOCALE:BOOL=ON
         -DBUILTIN_LSPROF:BOOL=ON
         -DBUILTIN_MATH:BOOL=ON
         -DBUILTIN_MMAP:BOOL=ON
         -DBUILTIN_MULTIBYTECODEC:BOOL=ON
         -DBUILTIN_MD5:BOOL=ON
         -DBUILTIN_MULTIPROCESSING:BOOL=ON
         -DBUILTIN_NIS:BOOL=ON
         -DBUILTIN_NIT:BOOL=ON
         -DBUILTIN_OPERATOR:BOOL=ON
         -DBUILTIN_PARSER:BOOL=ON
         -DBUILTIN_POSIX:BOOL=ON
         -DBUILTIN_PWD:BOOL=ON
         -DBUILTIN_PYEXPAT:BOOL=ON
         -DBUILTIN_READLINE:BOOL=ON
         -DBUILTIN_RESOURCE:BOOL=ON
         -DBULTIN_RANDOM:BOOL=ON
         -DBUILTIN_SCPROXY:BOOL=OFF
         -DBUILTIN_SELECT:BOOL=ON
         -DBUILTIN_SHA:BOOL=ON
         -DBUILTIN_SHA256:BOOL=ON
         -DBUILTIN_SHA512:BOOL=ON
         -DBUILTIN_SOCKET:BOOL=ON
         -DBUILTIN_SPWD:BOOL=ON
         -DBUILTIN_SQLITE3:BOOL=OFF
         -DBUILTIN_SSL:BOOL=ON
         -DBUILTIN_STROP:BOOL=ON
         -DBUILTIN_STRUCT:BOOL=ON
         -DBUILTIN_SUBPROCESS:BOOL=ON
         -DBUILTIN_SYSLOG:BOOL=ON
         -DBUILTIN_TERMIOS:BOOL=ON
         #-DBUILTIN_TESTCAPI:BOOL=OFF
         -DBUILTIN_TIME:BOOL=ON
         -DBUILTIN_TKINTER:BOOL=ON
         -DBUILTIN_UNICODEDATA:BOOL=ON
         -DBUILTIN_WINREG:BOOL=ON
         -DBUILTIN_ZLIB:BOOL=ON
         )
 
     # CMake build environment for python
     ExternalProject_Add(${proj}
       URL "https://dl.dropboxusercontent.com/u/8367205/ExternalProjects/python-cmake-buildsystem.tar.gz"
       URL_MD5 "171090922892acdaf1a155e22765d72d"
       SOURCE_DIR ${CMAKE_BINARY_DIR}/${proj}-src
       PREFIX ${proj}-cmake
       BINARY_DIR ${proj}-build
       INSTALL_DIR ${proj}-install
       CMAKE_ARGS
         ${ep_common_args}
         -DCMAKE_INSTALL_PREFIX:PATH=<INSTALL_DIR>
       CMAKE_CACHE_ARGS
         -DCMAKE_CXX_COMPILER:FILEPATH=${CMAKE_CXX_COMPILER}
         -DCMAKE_C_COMPILER:FILEPATH=${CMAKE_C_COMPILER}
         #-DBUILD_TESTING:BOOL=OFF
         -DBUILD_SHARED:BOOL=ON
         -DBUILD_STATIC:BOOL=OFF
         -DUSE_SYSTEM_LIBRARIES:BOOL=ON
         ${additional_cmake_cache_args}
       DEPENDS
         Python-src ${${proj}_DEPENDENCIES}
     )
 
     set(Python_DIR "${CMAKE_BINARY_DIR}/${proj}-install")
-    set(Python_BUILD_DIR "${CMAKE_BINARY_DIR}/${proj}-build")
 
-    # use the python executable in the build dir for unix systems. The stripped
-    # ones will cause conflicts if system libraries are present during the build/configure process
-    # of some toolkits, since they will try to lookup the sys path first if no lib is directly
-    # linked with it s path into the executable
+    set(PYTHON_EXECUTABLE "${Python_DIR}/bin/python${CMAKE_EXECUTABLE_SUFFIX}")
+
     if(UNIX)
-      set(PYTHON_EXECUTABLE "${Python_BUILD_DIR}/bin/python${CMAKE_EXECUTABLE_SUFFIX}")
+      #set(PYTHON_EXECUTABLE "${Python_BUILD_DIR}/bin/python${CMAKE_EXECUTABLE_SUFFIX}")
       set(PYTHON_INCLUDE_DIR "${Python_DIR}/include/python${PYTHON_MAJOR_VERSION}.${PYTHON_MINOR_VERSION}")
-      set(PYTHON_LIBRARY "${Python_BUILD_DIR}/lib/${CMAKE_SHARED_LIBRARY_PREFIX}python${PYTHON_MAJOR_VERSION}.${PYTHON_MINOR_VERSION}${CMAKE_SHARED_LIBRARY_SUFFIX}")
+      set(PYTHON_LIBRARY "${Python_DIR}/lib/${CMAKE_SHARED_LIBRARY_PREFIX}python${PYTHON_MAJOR_VERSION}.${PYTHON_MINOR_VERSION}${CMAKE_SHARED_LIBRARY_SUFFIX}")
+      #set(ENV{PYTHONHOME} "${Python_BUILD_DIR}")
     else()
-      set(PYTHON_EXECUTABLE "${Python_DIR}/bin/python${CMAKE_EXECUTABLE_SUFFIX}")
+      #set(PYTHON_EXECUTABLE "${Python_DIR}/bin/python${CMAKE_EXECUTABLE_SUFFIX}")
       set(PYTHON_INCLUDE_DIR "${Python_DIR}/include")
       set(PYTHON_LIBRARY "${Python_DIR}/libs/python${PYTHON_MAJOR_VERSION}${PYTHON_MINOR_VERSION}.lib")
     endif()
 
-    # get the name of the library
+    # export python home
+    set(ENV{PYTHONHOME} "${Python_DIR}")
+
+    # get the name of the library. The name is used for dynamic loading
+    # the library on unix systems in development setups
     get_filename_component(PYTHON_LIBRARY_NAME "${PYTHON_LIBRARY}" NAME)
 
   else()
     mitkMacroEmptyExternalProject(${proj} "${proj_DEPENDENCIES}")
   endif()
 endif()