diff --git a/CMake/mitkFunctionGetLibrarySearchPaths.cmake b/CMake/mitkFunctionGetLibrarySearchPaths.cmake
index 5d41fd95b8..49aa93da3b 100644
--- a/CMake/mitkFunctionGetLibrarySearchPaths.cmake
+++ b/CMake/mitkFunctionGetLibrarySearchPaths.cmake
@@ -1,138 +1,138 @@
 function(mitkFunctionGetLibrarySearchPaths search_path intermediate_dir)
 
   set(_dir_candidates
       "${MITK_CMAKE_RUNTIME_OUTPUT_DIRECTORY}"
       "${MITK_CMAKE_RUNTIME_OUTPUT_DIRECTORY}/plugins"
       "${MITK_CMAKE_LIBRARY_OUTPUT_DIRECTORY}"
       "${MITK_CMAKE_LIBRARY_OUTPUT_DIRECTORY}/plugins"
      )
   if(MITK_EXTERNAL_PROJECT_PREFIX)
     list(APPEND _dir_candidates
          "${MITK_EXTERNAL_PROJECT_PREFIX}/bin"
          "${MITK_EXTERNAL_PROJECT_PREFIX}/lib"
         )
   endif()
 
   # Determine the Qt4/5 library installation prefix
   set(_qmake_location )
   if(MITK_USE_Qt4)
     set(_qmake_location ${QT_QMAKE_EXECUTABLE})
   elseif(MITK_USE_Qt5 AND TARGET ${Qt5Core_QMAKE_EXECUTABLE})
     get_property(_qmake_location TARGET ${Qt5Core_QMAKE_EXECUTABLE}
                  PROPERTY IMPORT_LOCATION)
   endif()
   if(_qmake_location)
     if(NOT _qt_install_libs)
       if(WIN32)
         execute_process(COMMAND ${_qmake_location} -query QT_INSTALL_BINS
                         OUTPUT_VARIABLE _qt_install_libs
                         OUTPUT_STRIP_TRAILING_WHITESPACE)
       else()
         execute_process(COMMAND ${_qmake_location} -query QT_INSTALL_LIBS
                         OUTPUT_VARIABLE _qt_install_libs
                         OUTPUT_STRIP_TRAILING_WHITESPACE)
       endif()
       file(TO_CMAKE_PATH "${_qt_install_libs}" _qt_install_libs)
       set(_qt_install_libs ${_qt_install_libs} CACHE INTERNAL "Qt library installation prefix" FORCE)
     endif()
     if(_qt_install_libs)
       list(APPEND _dir_candidates ${_qt_install_libs})
     endif()
   elseif(MITK_USE_QT)
     message(WARNING "The qmake executable could not be found.")
   endif()
 
   get_property(_additional_paths GLOBAL PROPERTY MITK_ADDITIONAL_LIBRARY_SEARCH_PATHS)
   if(_additional_paths)
     list(APPEND _dir_candidates ${_additional_paths})
   endif()
 
   # The code below is sub-optimal. It makes assumptions about
   # the structure of the build directories, pointed to by
   # the *_DIR variables. Instead, we should rely on package
   # specific "LIBRARY_DIRS" variables, if they exist.
 
   if(WIN32)
     if(SOFA_DIR)
       list(APPEND _dir_candidates "${SOFA_DIR}/bin")
     endif()
   else()
     if(SOFA_DIR)
       list(APPEND _dir_candidates "${SOFA_DIR}/lib")
     endif()
   endif()
 
   if(OpenCV_DIR)
     set(_opencv_link_directories
       "${OpenCV_LIB_DIR_DBG}"
       "${OpenCV_LIB_DIR_OPT}"
       "${OpenCV_3RDPARTY_LIB_DIR_DBG}"
       "${OpenCV_3RDPARTY_LIB_DIR_OPT}")
     list(REMOVE_DUPLICATES _opencv_link_directories)
     if(WIN32)
       foreach(_opencv_link_directory ${_opencv_link_directories})
         list(APPEND _dir_candidates "${_opencv_link_directory}/../bin")
       endforeach()
     else()
       list(APPEND _dir_candidates ${_opencv_link_directories})
     endif()
   endif()
 
   if(MITK_USE_Python)
     list(APPEND _dir_candidates "${CTK_DIR}/CMakeExternals/Install/bin")
-    list(APPEND _dir_candidates "${Python_DIR}/lib/python2.7/bin")
+    list(APPEND _dir_candidates "${MITK_EXTERNAL_PROJECT_PREFIX}/lib/python2.7/bin")
   endif()
 
   if(MITK_USE_TOF_PMDO3 OR MITK_USE_TOF_PMDCAMCUBE OR MITK_USE_TOF_PMDCAMBOARD)
     list(APPEND _dir_candidates "${MITK_PMD_SDK_DIR}/plugins" "${MITK_PMD_SDK_DIR}/bin")
   endif()
 
   if(MITK_USE_CTK)
     list(APPEND _dir_candidates "${CTK_LIBRARY_DIRS}")
     foreach(_ctk_library ${CTK_LIBRARIES})
       if(${_ctk_library}_LIBRARY_DIRS)
         list(APPEND _dir_candidates "${${_ctk_library}_LIBRARY_DIRS}")
       endif()
     endforeach()
   endif()
 
   if(MITK_USE_BLUEBERRY)
     if(DEFINED CTK_PLUGIN_RUNTIME_OUTPUT_DIRECTORY)
       if(IS_ABSOLUTE "${CTK_PLUGIN_RUNTIME_OUTPUT_DIRECTORY}")
         list(APPEND _dir_candidates "${CTK_PLUGIN_RUNTIME_OUTPUT_DIRECTORY}")
       else()
         list(APPEND _dir_candidates "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${CTK_PLUGIN_RUNTIME_OUTPUT_DIRECTORY}")
       endif()
     endif()
   endif()
 
   if(MITK_LIBRARY_DIRS)
     list(APPEND _dir_candidates ${MITK_LIBRARY_DIRS})
   endif()
 
   list(REMOVE_DUPLICATES _dir_candidates)
 
   set(_search_dirs )
   foreach(_dir ${_dir_candidates})
     if(EXISTS "${_dir}/${intermediate_dir}")
       list(APPEND _search_dirs "${_dir}/${intermediate_dir}")
     else()
       list(APPEND _search_dirs "${_dir}")
     endif()
   endforeach()
 
   # Special handling for "internal" search dirs. The intermediate directory
   # might not have been created yet, so we can't check for its existence.
   # Hence we just add it for Windows without checking.
   set(_internal_search_dirs "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}" "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/plugins")
   if(WIN32)
     foreach(_dir ${_internal_search_dirs})
       set(_search_dirs "${_dir}/${intermediate_dir}" ${_search_dirs})
     endforeach()
   else()
     set(_search_dirs ${_internal_search_dirs} ${_search_dirs})
   endif()
   list(REMOVE_DUPLICATES _search_dirs)
 
   set(${search_path} ${_search_dirs} PARENT_SCOPE)
 endfunction()
diff --git a/CMake/mitkFunctionInstallPython.cmake b/CMake/mitkFunctionInstallPython.cmake
index 47a47b23b4..19b6df5c2f 100644
--- a/CMake/mitkFunctionInstallPython.cmake
+++ b/CMake/mitkFunctionInstallPython.cmake
@@ -1,61 +1,68 @@
 #! This CMake macro installs 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.
 #! _app_bundle App bundle name in case of a Apple bundle.
 #!
-function(mitkFunctionInstallPython _python_libs_out _app_bundle)
+function(mitkFunctionInstallPython _python_libs_out _search_path_out _app_bundle)
 
   # install the python runtime from the superbuild
   if(NOT MITK_USE_SYSTEM_PYTHON)
 
     # find package sets the python version numbers
     find_package(PythonLibs REQUIRED)
     find_package(PythonInterp REQUIRED)
 
     set(_python_libs )
+    set(_search_path )
 
     # set the destination bundle
     set(_destination bin)
     if(APPLE)
       set(_destination ${_app_bundle})
     endif()
 
     if(UNIX)
       list(APPEND _python_dirs "${MITK_EXTERNAL_PROJECT_PREFIX}/lib")
       set(PYTHON_LIB_SUFFIX ".so")
       set(_py_include_postfix python${PYTHON_VERSION_MAJOR}.${PYTHON_VERSION_MINOR}/)
-      set(_python_runtime_dir python${PYTHON_VERSION_MAJOR}.${PYTHON_VERSION_MINOR})
+      set(_python_runtime_dir python${PYTHON_VERSION_MAJOR}.${PYTHON_VERSION_MINOR}/)
     else() #WIN32
-      list(APPEND _python_dirs "${Python_DIR}/libs")
-      list(APPEND _python_dirs "${Python_DIR}/bin")
+      list(APPEND _python_dirs "${MITK_EXTERNAL_PROJECT_PREFIX}/lib/python${PYTHON_VERSION_MAJOR}.${PYTHON_VERSION_MINOR}/Lib")
+      #list(APPEND _python_dirs "${Python_DIR}/bin")
       set(PYTHON_LIB_SUFFIX .pyd)
       set(_py_include_postfix )
-      set(_python_runtime_dir Lib)
+      set(_python_runtime_dir )
+      set(_search_path "${MITK_EXTERNAL_PROJECT_PREFIX}/lib/python${PYTHON_VERSION_MAJOR}.${PYTHON_VERSION_MINOR}/bin")
     endif()
 
-    file(GLOB_RECURSE item RELATIVE "${_python_dirs}/${_python_runtime_dir}" "${_python_dirs}/${_python_runtime_dir}/*")
+    file(GLOB_RECURSE item RELATIVE "${_python_dirs}/${_python_runtime_dir}" "${_python_dirs}/${_python_runtime_dir}*")
     foreach(f ${item})
       get_filename_component(_filepath "${f}" PATH)
-      install(FILES "${_python_dirs}/${_python_runtime_dir}/${f}" DESTINATION "${_destination}/Python/lib/${_python_runtime_dir}/${_filepath}")
+      #message("f: " ${f})
+      #message("filepath: " ${_filepath})
+      install(FILES "${_python_dirs}/${_python_runtime_dir}${f}" DESTINATION "${_destination}/Python/lib/${_python_runtime_dir}${_filepath}")
 
-      #MESSAGE("For loop: " "${_python_dirs}/${_python_runtime_dir}/${f}")
+      #MESSAGE("in: " "${_python_dirs}/${_python_runtime_dir}${f}")
+      #MESSAGE("out: " "${_destination}/Python/lib/${_python_runtime_dir}${_filepath}")
       if(${f} MATCHES "(${PYTHON_LIB_SUFFIX})$")
-        list(APPEND _python_libs "Python/lib/${_python_runtime_dir}/${_filepath}")
+        MESSAGE("F: " ${f})
+        list(APPEND _python_libs "Python/lib/${_python_runtime_dir}${_filepath}")
         if(UNIX AND NOT APPLE)
           install(CODE "file(RPATH_REMOVE
-          FILE \"\${CMAKE_INSTALL_PREFIX}/bin/Python/lib/${_python_runtime_dir}/${f}\")")
+          FILE \"\${CMAKE_INSTALL_PREFIX}/bin/Python/lib/${_python_runtime_dir}${f}\")")
         endif()
       endif()
     endforeach()
 
     # config will by read out at runtime
     install(FILES "${PYTHON_INCLUDE_DIR}/pyconfig.h" DESTINATION ${_destination}/Python/include/${_py_include_postfix})
 
     set(${_python_libs_out} ${_python_libs} PARENT_SCOPE)
+    set(${_search_path_out} ${_search_path} PARENT_SCOPE)
   endif()
 endfunction()
 
diff --git a/CMake/mitkMacroInstall.cmake b/CMake/mitkMacroInstall.cmake
index 28046d8a25..c6b2d50623 100644
--- a/CMake/mitkMacroInstall.cmake
+++ b/CMake/mitkMacroInstall.cmake
@@ -1,186 +1,190 @@
 #
 # 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()
 
   if(MITK_USE_Python)
     include(mitkFunctionInstallPython)
-    mitkFunctionInstallPython(_python_libs "${_bundle_dest_dir}")
+    mitkFunctionInstallPython(_python_libs _python_search_paths "${_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})
+      MESSAGE("pylib: " ${_py_lib})
       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()
+    if(_python_search_paths)
+      set(DIRS \"\${DIRS};\${_python_search_paths}\")
+    endif()
     foreach(_plugin \${PLUGINS})
       get_filename_component(_pluginpath \${_plugin} PATH)
       list(APPEND DIRS \"\${_pluginpath}\")
     endforeach(_plugin)
 
     list(REMOVE_DUPLICATES DIRS)
 
     # use custom version of BundleUtilities
     include(BundleUtilities)
 
     fixup_bundle(\"\${CMAKE_INSTALL_PREFIX}/${_target_location}\" \"\${PLUGINS}\" \"\${DIRS}\")
   ")
 endmacro()