diff --git a/CMake/mitkMacroInstallPython.cmake b/CMake/mitkMacroInstallPython.cmake
index 510ec41d9a..307925cd02 100644
--- a/CMake/mitkMacroInstallPython.cmake
+++ b/CMake/mitkMacroInstallPython.cmake
@@ -1,138 +1,133 @@
 
 macro(MITK_INSTALL_PYTHON _python_libs _python_dirs)
 
   set(_destination bin)
   if(APPLE)
     set(_destination MitkWorkbench.app/Contents/MacOS)
   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_MAJOR_VERSION}.${PYTHON_MINOR_VERSION})
       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()
-      # install python stuff
-      #install(DIRECTORY "${Python_DIR}/lib/python${PYTHON_MAJOR_VERSION}.${PYTHON_MINOR_VERSION}"
-      #      DESTINATION ${_destination}/Python/lib
-      #      USE_SOURCE_PERMISSIONS
-      #      COMPONENT Runtime)
 
     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()
   endif()
 
   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()
 
   list(REMOVE_DUPLICATES _python_dirs)
 
 endmacro()
 
diff --git a/CMakeExternals/Numpy.cmake b/CMakeExternals/Numpy.cmake
index 6ab02f39c6..28a2fb3e02 100644
--- a/CMakeExternals/Numpy.cmake
+++ b/CMakeExternals/Numpy.cmake
@@ -1,140 +1,140 @@
-
+#-----------------------------------------------------------------------------
+# Numpy
+#-----------------------------------------------------------------------------
 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})
         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)
       set(ENV{PYTHONPATH} "${Numpy_DIR}")
     else()
       mitkMacroEmptyExternalProject(${proj} "${proj_DEPENDENCIES}")
     endif()
   endif()
 endif()
 
diff --git a/CMakeExternals/PCRE.cmake b/CMakeExternals/PCRE.cmake
index f904dce23f..aac94b7852 100644
--- a/CMakeExternals/PCRE.cmake
+++ b/CMakeExternals/PCRE.cmake
@@ -1,44 +1,39 @@
-
+#--------------------------------------------------------------------------
+#  PCRE (Perl Compatible Regular Expressions)
+#--------------------------------------------------------------------------
 if(MITK_USE_PCRE)
-  # Sanity checks
   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 dependency list
-  set(proj PCRE)
-  set(${proj}_DEPENDENCIES "")
-
+      message(FATAL_ERROR "PCRE_DIR variable is defined but corresponds to non-existing directory")
+   endif()
   if(NOT PCRE_DIR)
-    #
-    #  PCRE (Perl Compatible Regular Expressions)
-    #
 
+    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}
       PREFIX ${proj}-cmake
       CONFIGURE_COMMAND ${pcre_CONFIGURE_COMMAND}
       DEPENDS "${${proj}_DEPENDENCIES}"
       )
   else()
     mitkMacroEmptyExternalProject(${proj} "${${proj}_DEPENDENCIES}")
   endif()
 endif()
diff --git a/CMakeExternals/Python.cmake b/CMakeExternals/Python.cmake
index 60feceed7e..65877815c4 100644
--- a/CMakeExternals/Python.cmake
+++ b/CMakeExternals/Python.cmake
@@ -1,163 +1,165 @@
+#----------------------------------------------------------------------
+# Python
+#----------------------------------------------------------------------
 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 opencv, since they will try to lookup the sys path first if no lib is directly
     # linked with it s path into the executable
     if(UNIX)
       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(ENV{PYTHONHOME} "${Python_BUILD_DIR}")
     else()
       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")
       set(ENV{PYTHONHOME} "${Python_DIR}")
     endif()
 
     # get the name of the library
     get_filename_component(PYTHON_LIBRARY_NAME "${PYTHON_LIBRARY}" NAME)
 
   else()
     mitkMacroEmptyExternalProject(${proj} "${proj_DEPENDENCIES}")
   endif()
 endif()
 
diff --git a/CMakeExternals/SimpleITK.cmake b/CMakeExternals/SimpleITK.cmake
index 214c327591..71727c56b2 100644
--- a/CMakeExternals/SimpleITK.cmake
+++ b/CMakeExternals/SimpleITK.cmake
@@ -1,90 +1,92 @@
 #-----------------------------------------------------------------------------
 # 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()
 
   if(NOT MITK_USE_SYSTEM_PYTHON)
     list(APPEND proj_DEPENDENCIES Python)
   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
         )
 
     if(MITK_USE_Python)
       list(APPEND additional_cmake_args
         -DWRAP_PYTHON:BOOL=ON
           )
     endif(MITK_USE_Python)
 
+    #TODO: Installer and testing works only with static libs on MAC
     set(_build_shared ON)
     if(APPLE)
       set(_build_shared OFF)
     endif()
 
     set(SimpleITK_PATCH_COMMAND ${CMAKE_COMMAND} -DTEMPLATE_FILE:FILEPATH=${MITK_SOURCE_DIR}/CMakeExternals/EmptyFileForPatching.dummy -P ${MITK_SOURCE_DIR}/CMakeExternals/PatchSimpleITK.cmake)
 
     ExternalProject_Add(${proj}
        URL "https://dl.dropboxusercontent.com/u/8367205/ExternalProjects/SimpleITK.tar.gz"
        URL_MD5 "7cfa5d0ff79a540f4bcfaf992abe44d2"
        #GIT_TAG "493f15f5cfc620413d0aa7bb705ffe6d038a41b5"
        SOURCE_DIR ${CMAKE_BINARY_DIR}/${proj}-src
        BINARY_DIR ${proj}-build
        PREFIX ${proj}-cmake
        INSTALL_DIR ${proj}-install
        PATCH_COMMAND ${SimpleITK_PATCH_COMMAND}
        CMAKE_ARGS
          ${ep_common_args}
        CMAKE_CACHE_ARGS
          ${additional_cmake_args}
          -DBUILD_SHARED_LIBS:BOOL=${_build_shared}
          -DCMAKE_INSTALL_PREFIX:PATH=${CMAKE_CURRENT_BINARY_DIR}/${proj}-install
          -DCMAKE_INSTALL_NAME_DIR:STRING=<INSTALL_DIR>/lib
          -DSimpleITK_BUILD_DISTRIBUTE:BOOL=ON
          -DSimpleITK_PYTHON_THREADS:BOOL=ON
          -DUSE_SYSTEM_ITK:BOOL=ON
          -DBUILD_TESTING:BOOL=OFF
          -DBUILD_EXAMPLES:BOOL=OFF
          -DGDCM_DIR:PATH=${GDCM_DIR}
          -DITK_DIR:PATH=${ITK_DIR}
          -DPYTHON_EXECUTABLE:FILEPATH=${PYTHON_EXECUTABLE}
          -DPYTHON_INCLUDE_DIR:PATH=${PYTHON_INCLUDE_DIR}
          -DPYTHON_INCLUDE_DIR2:PATH=${PYTHON_INCLUDE_DIR2}
          -DPYTHON_LIBRARY:FILEPATH=${PYTHON_LIBRARY}
          -DSWIG_DIR:PATH=${SWIG_DIR}
          -DSWIG_EXECUTABLE:FILEPATH=${SWIG_EXECUTABLE}
        DEPENDS ${proj_DEPENDENCIES}
       )
 
     set(SimpleITK_DIR ${CMAKE_CURRENT_BINARY_DIR}/${proj}-build)
 
   else()
 
     mitkMacroEmptyExternalProject(${proj} "${proj_DEPENDENCIES}")
 
   endif()
 
 endif()
 
diff --git a/CMakeExternals/Swig.cmake b/CMakeExternals/Swig.cmake
index bdee0a408e..f234440a42 100644
--- a/CMakeExternals/Swig.cmake
+++ b/CMakeExternals/Swig.cmake
@@ -1,69 +1,70 @@
-
+#------------------------------------------------------------
+# SWIG (Simple Wrapper Interface Generator)
+#-----------------------------------------------------------
 if(MITK_USE_SWIG)
-  # Sanity checks
   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
         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}
         PREFIX ${proj}-cmake
         BUILD_IN_SOURCE 1
         CONFIGURE_COMMAND ${swig_CONFIGURE_COMMAND}
         DEPENDS ${Swig_DEPENDENCIES}
         )
 
       set(SWIG_DIR ${swig_install_dir}/share/swig/${SWIG_TARGET_VERSION})
       set(SWIG_EXECUTABLE ${swig_install_dir}/bin/swig)
 
     endif()
   endif(NOT SWIG_DIR)
 endif()
diff --git a/CMakeExternals/VTK.cmake b/CMakeExternals/VTK.cmake
index f48e52eef2..0d48b4186d 100644
--- a/CMakeExternals/VTK.cmake
+++ b/CMakeExternals/VTK.cmake
@@ -1,102 +1,100 @@
 #-----------------------------------------------------------------------------
 # 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(NOT DEFINED VTK_DIR)
 
   set(additional_cmake_args )
   if(MINGW)
     set(additional_cmake_args
         -DCMAKE_USE_WIN32_THREADS:BOOL=ON
         -DCMAKE_USE_PTHREADS:BOOL=OFF
         -DVTK_USE_VIDEO4WINDOWS:BOOL=OFF # no header files provided by MinGW
         )
   endif()
 
   if(MITK_USE_Python)
     if(NOT MITK_USE_SYSTEM_PYTHON)
      list(APPEND proj_DEPENDENCIES Python)
     endif()
     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}
-         #-DPYTHON_LIBRARIES=${PYTHON_LIBRARY}
-         #-DPYTHON_DEBUG_LIBRARIES=${PYTHON_DEBUG_LIBRARIES}
         )
   else()
     list(APPEND additional_cmake_args
          -DVTK_WRAP_PYTHON:BOOL=OFF
          -DVTK_WINDOWS_PYTHON_DEBUGGABLE:BOOL=OFF
         )
   endif()
 
   if(MITK_USE_QT)
     if(DESIRED_QT_VERSION MATCHES 4) # current VTK package has a HARD Qt 4 dependency
       list(APPEND additional_cmake_args
           -DDESIRED_QT_VERSION:STRING=${DESIRED_QT_VERSION}
           -DVTK_USE_GUISUPPORT:BOOL=ON
           -DVTK_USE_QVTK_QTOPENGL:BOOL=OFF
           -DVTK_USE_QT:BOOL=ON
           -DQT_QMAKE_EXECUTABLE:FILEPATH=${QT_QMAKE_EXECUTABLE}
           -DModule_vtkGUISupportQt:BOOL=ON
           -DModule_vtkGUISupportQtWebkit:BOOL=ON
           -DModule_vtkGUISupportQtSQL:BOOL=ON
           -DModule_vtkRenderingQt:BOOL=ON
           -DVTK_Group_Qt:BOOL=ON
        )
      endif()
   endif()
 
   set(VTK_URL ${MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL}/VTK-6.1.0.tar.gz)
   set(VTK_URL_MD5 25e4dfb3bad778722dcaec80cd5dab7d)
 
 
   ExternalProject_Add(${proj}
     SOURCE_DIR ${CMAKE_BINARY_DIR}/${proj}-src
     BINARY_DIR ${proj}-build
     PREFIX ${proj}-cmake
     URL ${VTK_URL}
     URL_MD5 ${VTK_URL_MD5}
     INSTALL_COMMAND ""
     CMAKE_GENERATOR ${gen}
     CMAKE_ARGS
         ${ep_common_args}
         -DVTK_WRAP_TCL:BOOL=OFF
         -DVTK_WRAP_PYTHON:BOOL=OFF
         -DVTK_WRAP_JAVA:BOOL=OFF
         -DBUILD_SHARED_LIBS:BOOL=ON
         -DVTK_USE_SYSTEM_FREETYPE:BOOL=${VTK_USE_SYSTEM_FREETYPE}
         -DVTK_LEGACY_REMOVE:BOOL=ON
         -DModule_vtkTestingRendering:BOOL=ON
         -DVTK_MAKE_INSTANTIATORS:BOOL=ON
         ${additional_cmake_args}
      DEPENDS ${proj_DEPENDENCIES}
     )
 
   set(VTK_DIR ${CMAKE_CURRENT_BINARY_DIR}/${proj}-build)
 
 else()
 
   mitkMacroEmptyExternalProject(${proj} "${proj_DEPENDENCIES}")
 
 endif()
diff --git a/CMakeExternals/swig_configure_step.cmake.in b/CMakeExternals/swig_configure_step.cmake.in
index 3b029e4696..13708fe173 100644
--- a/CMakeExternals/swig_configure_step.cmake.in
+++ b/CMakeExternals/swig_configure_step.cmake.in
@@ -1,28 +1,24 @@
-# Set the important envirimental variables that auto-conf uses to
-# configure, mostly these are passed from the CMake
-# configuration. Others are just explicitly passed from the
-# enviroment. If there is a problem with them in the future they can
-# be addressed in CMake with the same structure.
+# 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 d3e424664e..67ab31b50f 100644
--- a/Modules/Python/CMakeLists.txt
+++ b/Modules/Python/CMakeLists.txt
@@ -1,21 +1,20 @@
 if( MITK_USE_Python )
   if(NOT MITK_USE_SYSTEM_PYTHON)
     add_definitions( -DUSE_MITK_BUILTIN_PYTHON )
   endif()
 
   set(OpenCV_DEP )
-  set(SimpleITK_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()