diff --git a/CMakeExternals/OpenCV.cmake b/CMakeExternals/OpenCV.cmake
new file mode 100644
index 0000000000..88028d78d8
--- /dev/null
+++ b/CMakeExternals/OpenCV.cmake
@@ -0,0 +1,38 @@
+#-----------------------------------------------------------------------------
+# OpenCV
+#-----------------------------------------------------------------------------
+
+IF(MITK_USE_OPEN_CV)
+
+# 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)
+  ExternalProject_Add(${proj}
+     URL http://mitk.org/download/thirdparty/OpenCV-2.2.0.tar.bz2
+     BINARY_DIR ${proj}-build
+     INSTALL_COMMAND ""
+     CMAKE_GENERATOR ${gen}
+     CMAKE_ARGS
+       ${ep_common_args}
+       -DBUILD_TESTS:BOOL=OFF
+       -DBUILD_EXAMPLES:BOOL=OFF
+       -DBUILD_DOXYGEN_DOCS:BOOL=OFF
+     DEPENDS ${proj_DEPENDENCIES}
+    )
+
+  SET(OpenCV_DIR ${CMAKE_CURRENT_BINARY_DIR}/${proj}-build)
+
+ELSE()
+
+  mitkMacroEmptyExternalProject(${proj} "${proj_DEPENDENCIES}")
+
+ENDIF()
+
+ENDIF()
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 2622e92260..35cedc0a27 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,403 +1,404 @@
 cmake_minimum_required(VERSION 2.8.2)
 
 project(MITK)
 
 #-----------------------------------------------------------------------------
 # See http://cmake.org/cmake/help/cmake-2-8-docs.html#section_Policies for details
 #-----------------------------------------------------------------------------
 
 set(project_policies
   CMP0001 # NEW: CMAKE_BACKWARDS_COMPATIBILITY should no longer be used.
   CMP0002 # NEW: Logical target names must be globally unique.
   CMP0003 # NEW: Libraries linked via full path no longer produce linker search paths.
   CMP0004 # NEW: Libraries linked may NOT have leading or trailing whitespace.
   CMP0005 # NEW: Preprocessor definition values are now escaped automatically.
   CMP0006 # NEW: Installing MACOSX_BUNDLE targets requires a BUNDLE DESTINATION.
   CMP0007 # NEW: List command no longer ignores empty elements.
   CMP0008 # NEW: Libraries linked by full-path must have a valid library file name.
   CMP0009 # NEW: FILE GLOB_RECURSE calls should not follow symlinks by default.
   CMP0010 # NEW: Bad variable reference syntax is an error.
   CMP0011 # NEW: Included scripts do automatic cmake_policy PUSH and POP.
   CMP0012 # NEW: if() recognizes numbers and boolean constants.
   CMP0013 # NEW: Duplicate binary directories are not allowed.
   CMP0014 # NEW: Input directories must have CMakeLists.txt
   )
 foreach(policy ${project_policies})
   if(POLICY ${policy})
     cmake_policy(SET ${policy} NEW)
   endif()
 endforeach()
 
 #-----------------------------------------------------------------------------
 # Update CMake module path
 #------------------------------------------------------------------------------
 
 set(CMAKE_MODULE_PATH
   ${MITK_SOURCE_DIR}/CMake
   ${CMAKE_MODULE_PATH}
   )
 
 #-----------------------------------------------------------------------------
 # CMake Function(s) and Macro(s)
 #-----------------------------------------------------------------------------
 
 include(mitkMacroEmptyExternalProject)
 
 #-----------------------------------------------------------------------------
 # Superbuild Option - Enabled by default
 #-----------------------------------------------------------------------------
 
 option(MITK_USE_SUPERBUILD "Build MITK and the projects it depends on via SuperBuild.cmake." ON)
 
 #-----------------------------------------------------------------------------
 # Output directories.
 #-----------------------------------------------------------------------------
 
 foreach(type LIBRARY RUNTIME ARCHIVE)
   # Make sure the directory exists
   if(DEFINED MITK_CMAKE_${type}_OUTPUT_DIRECTORY
      AND NOT EXISTS ${MITK_CMAKE_${type}_OUTPUT_DIRECTORY})
     message(FATAL_ERROR "MITK_CMAKE_${type}_OUTPUT_DIRECTORY is set to a non-existing directory [${MITK_CMAKE_${type}_OUTPUT_DIRECTORY}]")
   endif()
   
   if(MITK_USE_SUPERBUILD)
     set(output_dir ${MITK_BINARY_DIR}/bin)
     if(NOT DEFINED MITK_CMAKE_${type}_OUTPUT_DIRECTORY)
       set(MITK_CMAKE_${type}_OUTPUT_DIRECTORY ${MITK_BINARY_DIR}/MITK-build/bin)
     endif()
   else()
     if(NOT DEFINED MITK_CMAKE_${type}_OUTPUT_DIRECTORY)
       SET(output_dir ${MITK_BINARY_DIR}/bin)
     else()
       SET(output_dir ${MITK_CMAKE_${type}_OUTPUT_DIRECTORY})
     endif()
   endif()
   set(CMAKE_${type}_OUTPUT_DIRECTORY ${output_dir} CACHE INTERNAL "Single output directory for building all libraries.")
   mark_as_advanced(CMAKE_${type}_OUTPUT_DIRECTORY)
 endforeach()
 
 #-----------------------------------------------------------------------------
 # Additional MITK Options (also shown during superbuild)
 #-----------------------------------------------------------------------------
 
 option(BUILD_SHARED_LIBS "Build MITK with shared libraries" ON)
 option(WITH_COVERAGE "Enable/Disable coverage" OFF)
 option(BUILD_TESTING "Test the project" ON)
 
 # some targets in Utilities also depend on Qt. Use this option
 # to decide if they should be build
 option(MITK_USE_QT "Use Trolltech's Qt library" ON)
 if(MITK_USE_QT)
   # find the package at the very beginning, so that QT4_FOUND is available
   find_package(Qt4 4.6.0 REQUIRED)
 endif()
 
 option(MITK_INSTALL_RPATH_RELATIVE "Use relative rpath entries for installation packages" OFF)
 option(MITK_BUILD_ALL_PLUGINS "Build all MITK plugins" OFF)
 option(MITK_BUILD_TUTORIAL "Build the MITK tutorial" ON)
 option(MITK_USE_Boost "Use the Boost C++ library" OFF)
 option(MITK_USE_GDCMIO "Use the GDCMIO class instead of ImageIO2 for DICOM" ON)
 option(MITK_USE_BLUEBERRY "Build the BlueBerry platform" ON)
 option(MITK_USE_CTK "EXEPERIMENTAL, superbuild only: Use CTK in MITK" OFF)
 option(MITK_USE_DCMTK "EXEPERIMENTAL, superbuild only: Use DCMTK in MITK" OFF)
+option(MITK_USE_OPEN_CV "Use Intel's OpenCV library" OFF)
   
 mark_as_advanced(MITK_INSTALL_RPATH_RELATIVE
                  MITK_BUILD_ALL_PLUGINS
                  MITK_USE_CTK
                  MITK_USE_DCMTK
                  )
 
 #-----------------------------------------------------------------------------
 # Additional CXX/C Flags
 #-----------------------------------------------------------------------------
 
 set(ADDITIONAL_C_FLAGS "" CACHE STRING "Additional C Flags")
 mark_as_advanced(ADDITIONAL_C_FLAGS)
 set(ADDITIONAL_CXX_FLAGS "" CACHE STRING "Additional CXX Flags")
 mark_as_advanced(ADDITIONAL_CXX_FLAGS)
 
 #-----------------------------------------------------------------------------
 # Superbuild script
 #-----------------------------------------------------------------------------
 
 if(MITK_USE_SUPERBUILD)
   include("${CMAKE_CURRENT_SOURCE_DIR}/SuperBuild.cmake")
   return()
 endif()
 
 #*****************************************************************************
 #****************************  END OF SUPERBUILD  ****************************
 #*****************************************************************************
 
 #-----------------------------------------------------------------------------
 # CMake Function(s) and Macro(s)
 #-----------------------------------------------------------------------------
 
 include(mitkFunctionCheckCompilerFlags)
 include(mitkFunctionGetGccVersion)
 include(MacroParseArguments)
 include(mitkFunctionSuppressWarnings) # includes several functions
 include(mitkFunctionOrganizeSources)
 include(mitkFunctionGetVersion)
 include(mitkFunctionCreateWindowsBatchScript)
 include(mitkMacroCreateModuleConf)
 include(mitkMacroCreateModule)
 include(mitkMacroCheckModule)
 include(mitkMacroCreateModuleTests)
 include(mitkMacroUseModule)
 include(mitkMacroMultiplexPicType)
 include(mitkMacroInstall)
 include(mitkMacroInstallHelperApp)
 include(mitkMacroInstallTargets)
 include(mitkMacroGenerateToolsLibrary)
 
 #-----------------------------------------------------------------------------
 # Prerequesites
 #-----------------------------------------------------------------------------
 
 find_package(ITK REQUIRED)
 find_package(VTK REQUIRED)
 
 #-----------------------------------------------------------------------------
 # Set MITK specific options and variables (NOT available during superbuild)
 #-----------------------------------------------------------------------------
 
 # ASK THE USER TO SHOW THE CONSOLE WINDOW FOR CoreApp and ExtApp
 option(MITK_SHOW_CONSOLE_WINDOW "Use this to enable or disable the console window when starting MITK GUI Applications" ON)
 mark_as_advanced(MITK_SHOW_CONSOLE_WINDOW)
 
 # TODO: check if necessary
 option(USE_ITKZLIB "Use the ITK zlib for pic compression." ON)
 mark_as_advanced(USE_ITKZLIB)
 
 #-----------------------------------------------------------------------------
 # Get MITK version info
 #-----------------------------------------------------------------------------
 
 mitkFunctionGetVersion(${MITK_SOURCE_DIR} MITK)
 
 #-----------------------------------------------------------------------------
 # Set symbol visibility Flags
 #-----------------------------------------------------------------------------
 
 # MinGW does not export all symbols automatically, so no need to set flags
 if(CMAKE_COMPILER_IS_GNUCXX AND NOT MINGW)
   set(VISIBILITY_CXX_FLAGS ) #"-fvisibility=hidden -fvisibility-inlines-hidden")
 endif()
 
 #-----------------------------------------------------------------------------
 # Set coverage Flags
 #-----------------------------------------------------------------------------
 
 if(WITH_COVERAGE)
   if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
     set(coverage_flags "-g -fprofile-arcs -ftest-coverage -O0 -DNDEBUG")
     set(COVERAGE_CXX_FLAGS ${coverage_flags})
     set(COVERAGE_C_FLAGS ${coverage_flags})
   endif()
 endif()
 
 #-----------------------------------------------------------------------------
 # MITK C/CXX Flags
 #-----------------------------------------------------------------------------
 
 set(MITK_C_FLAGS "${CMAKE_C_FLAGS} ${COVERAGE_C_FLAGS} ${ADDITIONAL_C_FLAGS}")
 set(MITK_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${VISIBILITY_CXX_FLAGS} ${COVERAGE_CXX_FLAGS} ${ADDITIONAL_CXX_FLAGS}")
 
 if(CMAKE_COMPILER_IS_GNUCXX)
   set(cflags "-Wall -Wextra -Wpointer-arith -Winvalid-pch -Wcast-align -Wwrite-strings -D_FORTIFY_SOURCE=2")
   
   mitkFunctionCheckCompilerFlags("-fdiagnostics-show-option" cflags)
   mitkFunctionCheckCompilerFlags("-Wl,--no-undefined" cflags)
   
   mitkFunctionGetGccVersion(${CMAKE_CXX_COMPILER} GCC_VERSION)
   # With older version of gcc supporting the flag -fstack-protector-all, an extra dependency to libssp.so
   # is introduced. If gcc is smaller than 4.4.0 and the build type is Release let's not include the flag.
   # Doing so should allow to build package made for distribution using older linux distro.
   if(${GCC_VERSION} VERSION_GREATER "4.4.0" OR (CMAKE_BUILD_TYPE STREQUAL "Debug" AND ${GCC_VERSION} VERSION_LESS "4.4.0"))
     mitkFunctionCheckCompilerFlags("-fstack-protector-all" cflags)
   endif()
   if(MINGW)
     # suppress warnings about auto imported symbols
     set(MITK_CXX_FLAGS "-Wl,--enable-auto-import ${MITK_CXX_FLAGS}")  
     # we need to define a Windows version
     set(MITK_CXX_FLAGS "-D_WIN32_WINNT=0x0500 ${MITK_CXX_FLAGS}")
   endif()
   
   set(MITK_C_FLAGS "${cflags} ${MITK_C_FLAGS}")
   #set(MITK_CXX_FLAGS "${cflags} -Woverloaded-virtual -Wold-style-cast -Wstrict-null-sentinel -Wsign-promo ${MITK_CXX_FLAGS}")
   set(MITK_CXX_FLAGS "${cflags} -Woverloaded-virtual -Wstrict-null-sentinel ${MITK_CXX_FLAGS}")
 endif()
 
 #-----------------------------------------------------------------------------
 # MITK Modules
 #-----------------------------------------------------------------------------
 
 set(MITK_MODULES_CONF_DIR ${MITK_BINARY_DIR}/modulesConf CACHE INTERNAL "Modules Conf")
 set(MITK_MODULES_PACKAGE_DEPENDS_DIR ${MITK_SOURCE_DIR}/CMake/PackageDepends)
 set(MODULES_PACKAGE_DEPENDS_DIRS ${MITK_MODULES_PACKAGE_DEPENDS_DIR})
 
 #-----------------------------------------------------------------------------
 # Testing
 #-----------------------------------------------------------------------------
 
 if(BUILD_TESTING)
   enable_testing()
   include(CTest)
   mark_as_advanced(TCL_TCLSH DART_ROOT)
     
   # Setup file for setting custom ctest vars
   configure_file(
     CMake/CTestCustom.cmake.in
     ${MITK_BINARY_DIR}/CTestCustom.cmake
     @ONLY
     )
 
   # Configuration for the CMake-generated test driver
   set(CMAKE_TESTDRIVER_EXTRA_INCLUDES "#include <stdexcept>")
   set(CMAKE_TESTDRIVER_BEFORE_TESTMAIN "
     try
       {")
   set(CMAKE_TESTDRIVER_AFTER_TESTMAIN "    }
       catch( std::exception & excp )
         {
         fprintf(stderr,\"%s\\n\",excp.what());
         return EXIT_FAILURE;
         }
       catch( ... )
         {
         printf(\"Exception caught in the test driver\\n\");
         return EXIT_FAILURE;
         }
       ")
       
   set(MITK_TEST_OUTPUT_DIR "${MITK_BINARY_DIR}/test_output")
   if(NOT EXISTS ${MITK_TEST_OUTPUT_DIR})
     file(MAKE_DIRECTORY ${MITK_TEST_OUTPUT_DIR})
   endif()
   configure_file(mitkTestingConfig.h.in ${MITK_BINARY_DIR}/mitkTestingConfig.h)
 endif()
 
 #-----------------------------------------------------------------------------
 # MITK_SUPERBUILD_BINARY_DIR
 #-----------------------------------------------------------------------------
 
 # If MITK_SUPERBUILD_BINARY_DIR isn't defined, it means MITK is *NOT* build using Superbuild.
 # In that specific case, MITK_SUPERBUILD_BINARY_DIR should default to MITK_BINARY_DIR
 if(NOT DEFINED MITK_SUPERBUILD_BINARY_DIR)
   set(MITK_SUPERBUILD_BINARY_DIR ${MITK_BINARY_DIR})
 endif()
 
 #-----------------------------------------------------------------------------
 # Compile Utilities and set-up MITK variables
 #-----------------------------------------------------------------------------
 
 add_subdirectory(Utilities)
 
 include(mitkSetupVariables)
 if(MITK_USE_BLUEBERRY)
   include(mitkSetupBlueBerry)
 endif()
 
 #-----------------------------------------------------------------------------
 # Set C/CXX Flags for MITK code
 #-----------------------------------------------------------------------------
 
 set(CMAKE_CXX_FLAGS ${MITK_CXX_FLAGS})
 set(CMAKE_C_FLAGS ${MITK_C_FLAGS})
 
 if(MITK_USE_QT)
   add_definitions(-DQWT_DLL)
 endif()
 
 #-----------------------------------------------------------------------------
 # Add subdirectories
 #-----------------------------------------------------------------------------
 
 link_directories(${MITK_LINK_DIRECTORIES})
 
 add_subdirectory(Core)
 add_subdirectory(CoreUI)
 add_subdirectory(Modules)
 add_subdirectory(Applications)
 
 #-----------------------------------------------------------------------------
 # Python Wrapping
 #-----------------------------------------------------------------------------
 
 set(MITK_WRAPPING_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/Wrapping)
 set(MITK_WRAPPING_BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR}/Wrapping)
 option(MITK_USE_PYTHON "Build cswig Python wrapper support (requires CableSwig)." OFF)
 if(MITK_USE_PYTHON)
   add_subdirectory(Wrapping)
 endif()
 
 #-----------------------------------------------------------------------------
 # Documentation
 #-----------------------------------------------------------------------------
 
 add_subdirectory(Documentation)
 
 #-----------------------------------------------------------------------------
 # Installation
 #-----------------------------------------------------------------------------
 
 if(MITK_INSTALL_RPATH_RELATIVE)
   set(CMAKE_INSTALL_RPATH ".")
 else()
   set(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/bin")
 endif()
 
 # on Mac OSX all BlueBerry plugins get copied into every
 # application bundle (.app directory) specified here
 if(APPLE)
   if(MITK_BUILD_org.mitk.gui.qt.extapplication)
     set(MACOSX_BUNDLE_NAMES ${MACOSX_BUNDLE_NAMES} ExtApp)
   endif()
   if(MITK_BUILD_org.mitk.gui.qt.application)
     set(MACOSX_BUNDLE_NAMES ${MACOSX_BUNDLE_NAMES} CoreApp)
   endif()
 endif(APPLE)
 
 # set MITK cpack variables
 include(mitkSetupCPack)
 
 if(MITK_BUILD_org.mitk.gui.qt.application)
   list(APPEND CPACK_CREATE_DESKTOP_LINKS "CoreApp")
 endif()
 if(MITK_BUILD_org.mitk.gui.qt.extapplication)
   list(APPEND CPACK_CREATE_DESKTOP_LINKS "ExtApp")
 endif()
 
 
 configure_file(${MITK_SOURCE_DIR}/MITKCPackOptions.cmake.in
                ${MITK_BINARY_DIR}/MITKCPackOptions.cmake @ONLY)
 set(CPACK_PROJECT_CONFIG_FILE "${MITK_BINARY_DIR}/MITKCPackOptions.cmake")
 
 # include CPack model once all variables are set
 include(CPack)
 
 # Additional installation rules
 include(mitkInstallRules)
 
 #-----------------------------------------------------------------------------
 # Last configuration steps
 #-----------------------------------------------------------------------------
 
 configure_file(${MITK_SOURCE_DIR}/CMake/ToolExtensionITKFactory.cpp.in
                ${MITK_BINARY_DIR}/ToolExtensionITKFactory.cpp.in COPYONLY)
 configure_file(${MITK_SOURCE_DIR}/CMake/ToolExtensionITKFactoryLoader.cpp.in
                ${MITK_BINARY_DIR}/ToolExtensionITKFactoryLoader.cpp.in COPYONLY)
 configure_file(${MITK_SOURCE_DIR}/CMake/ToolGUIExtensionITKFactory.cpp.in
                ${MITK_BINARY_DIR}/ToolGUIExtensionITKFactory.cpp.in COPYONLY)
 
 configure_file(mitkVersion.h.in ${MITK_BINARY_DIR}/mitkVersion.h)
 configure_file(mitkConfig.h.in ${MITK_BINARY_DIR}/mitkConfig.h)
 
 set(VECMATH_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/Utilities/vecmath)
 set(IPFUNC_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/Utilities/ipFunc)
 set(UTILITIES_DIR ${CMAKE_CURRENT_SOURCE_DIR}/Utilities)
 
 configure_file(mitkConfig.h.in ${MITK_BINARY_DIR}/mitkConfig.h)
 configure_file(MITKConfig.cmake.in ${MITK_BINARY_DIR}/MITKConfig.cmake @ONLY)
 
diff --git a/MITKConfig.cmake.in b/MITKConfig.cmake.in
index c3d7428242..2a47333380 100644
--- a/MITKConfig.cmake.in
+++ b/MITKConfig.cmake.in
@@ -1,114 +1,116 @@
 
 # Update the CMake module path
 SET(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "@MITK_SOURCE_DIR@/CMake")
 
 # Include MITK macros
 include(MacroParseArguments)
 include(mitkFunctionOrganizeSources)
 include(mitkMacroCreateModuleConf)
 include(mitkMacroCreateModule)
 include(mitkMacroCheckModule)
 include(mitkMacroCreateModuleTests)
 include(mitkMacroUseModule)
 include(mitkMacroMultiplexPicType)
 include(mitkMacroInstall)
 include(mitkMacroInstallHelperApp)
 include(mitkMacroInstallTargets)
 include(mitkMacroGenerateToolsLibrary)
 
 # The MITK version number
 SET(MITK_VERSION_MAJOR "@MITK_VERSION_MAJOR@")
 SET(MITK_VERSION_MINOR "@MITK_VERSION_MINOR@")
 SET(MITK_VERSION_PATCH "@MITK_VERSION_PATCH@")
 
 # MITK specific variables
 SET(MITK_SOURCE_DIR "@MITK_SOURCE_DIR@")
 SET(UTILITIES_DIR "@UTILITIES_DIR@")
 SET(REGISTER_QFUNCTIONALITY_CPP_IN "@REGISTER_QFUNCTIONALITY_CPP_IN@")
 SET(MITK_MODULES_CONF_DIR "@MITK_MODULES_CONF_DIR@")
 SET(MITK_MODULES_PACKAGE_DEPENDS_DIR "@MITK_MODULES_PACKAGE_DEPENDS_DIR@")
 SET(MODULES_PACKAGE_DEPENDS_DIRS "@MODULES_PACKAGE_DEPENDS_DIRS@")
 
 # Include directory variables
 SET(MITK_INCLUDE_DIRS "@MITK_INCLUDE_DIRS@")
 SET(QMITK_INCLUDE_DIRS "@QMITK_INCLUDE_DIRS@")
 SET(ANN_INCLUDE_DIR "@ANN_INCLUDE_DIR@")
 SET(IPSEGMENTATION_INCLUDE_DIR "@IPSEGMENTATION_INCLUDE_DIR@")
 SET(VECMATH_INCLUDE_DIR "@VECMATH_INCLUDE_DIR@")
 SET(IPFUNC_INCLUDE_DIR "@IPFUNC_INCLUDE_DIR@")
 SET(MITK_IGT_INCLUDE_DIRS "@MITK_IGT_INCLUDE_DIRS@")
 
 # Library variables
 SET(MITK_LIBRARIES "@MITK_LIBRARIES@")
 SET(QMITK_LIBRARIES "@QMITK_LIBRARIES@")
 
 # Link directory variables
 SET(MITK_LINK_DIRECTORIES "@MITK_LINK_DIRECTORIES@")
 SET(QMITK_LINK_DIRECTORIES "@QMITK_LINK_DIRECTORIES@")
 SET(MITK_LIBRARY_DIRS "@CMAKE_LIBRARY_OUTPUT_DIRECTORY@")
 SET(MITK_VTK_LIBRARY_DIRS "@VTK_LIBRARY_DIRS@")
 SET(MITK_ITK_LIBRARY_DIRS "@ITK_LIBRARY_DIRS@")
 
 # External projects
 SET(ITK_DIR "@ITK_DIR@")
 SET(VTK_DIR "@VTK_DIR@")
 SET(DCMTK_DIR "@DCMTK_DIR@")
 SET(GDCM_DIR "@GDCM_DIR@")
 SET(BOOST_ROOT "@BOOST_ROOT@")
+SET(OpenCV_DIR "@OpenCV_DIR@")
 SET(MITK_QMAKE_EXECUTABLE "@QT_QMAKE_EXECUTABLE@")
 SET(MITK_INSTALL_RPATH_RELATIVE @MITK_INSTALL_RPATH_RELATIVE@)
 
 # MITK use variables
 SET(MITK_USE_QT @MITK_USE_QT@)
 SET(MITK_USE_BLUEBERRY @MITK_USE_BLUEBERRY@)
 SET(MITK_USE_Boost @MITK_USE_Boost@)
 SET(MITK_USE_CTK @MITK_USE_CTK@)
 SET(MITK_USE_GDCMIO @MITK_USE_GDCMIO@)
 SET(MITK_USE_DCMTK @MITK_USE_DCMTK@)
+SET(MITK_USE_OPEN_CV @MITK_USE_OPEN_CV@)
 
 # There is no PocoConfig.cmake, so we set Poco specific CMake variables
 # here. This way the call to FIND_PACKAGE(Poco) in BlueBerryConfig.cmake
 # finds the Poco distribution supplied by MITK
 SET(Poco_INCLUDE_DIR "@MITK_SOURCE_DIR@/Utilities/Poco")
 SET(Poco_LIBRARY_DIR "@MITK_BINARY_DIR@/bin")
 
 
 IF(MITK_USE_EXT)
   #INCLUDE(${MITK_DIR}/mitkExtConfig.cmake)
   #INCLUDE(${MITK_DIR}/QmitkExtConfig.cmake)
 ENDIF()
 
 IF(MITK_USE_IGT)
   #INCLUDE(${MITK_DIR}/mitkIGTConfig.cmake)
 ENDIF()
 
 # BlueBerry support
 IF(MITK_USE_BLUEBERRY)
 
   SET(BlueBerry_DIR "@MITK_BINARY_DIR@/BlueBerry")
 
   INCLUDE(mitkMacroCreatePlugin)
 
   IF(NOT MITK_SKIP_BUNDLELIST)
     INCLUDE("@MITK_BINARY_DIR@/Bundles/MITKCoreBundleList.cmake")
     IF(MITK_USE_EXT)
       INCLUDE("@MITK_BINARY_DIR@/Bundles/MITKModulesBundleList.cmake")
     ENDIF()
   ENDIF(NOT MITK_SKIP_BUNDLELIST)
   
   FIND_PACKAGE(BlueBerry)
 
   IF(NOT BlueBerry_FOUND)
     MESSAGE(SEND_ERROR "MITK does not seem to be configured with BlueBerry support. Set MITK_USE_BLUEBERRY to ON in your MITK build configuration.")
   ENDIF(NOT BlueBerry_FOUND)
   
   SET(BLUEBERRY_OSGI_LINK_DIR "@BLUEBERRY_PLUGINS_OUTPUT_DIR@/org.blueberry.osgi/bin")
 
   SET(MITK_PLUGIN_SOURCE_DIRS "@MITK_SOURCE_DIR@/Bundles")
   
   SET(MITK_PLUGIN_OUTPUT_DIRS @MITK_CORE_PLUGIN_OUTPUT_DIRS@)
   IF(MITK_USE_EXT)
     LIST(APPEND MITK_PLUGIN_OUTPUT_DIRS @MITK_MODULES_PLUGIN_OUTPUT_DIRS@)
   ENDIF()
 
 ENDIF(MITK_USE_BLUEBERRY)
diff --git a/Modules/OpenCVVideoSupport/CMakeLists.txt b/Modules/OpenCVVideoSupport/CMakeLists.txt
index 5cd38a3896..5b0ecfa654 100644
--- a/Modules/OpenCVVideoSupport/CMakeLists.txt
+++ b/Modules/OpenCVVideoSupport/CMakeLists.txt
@@ -1,48 +1,47 @@
-OPTION(MITK_USE_OPEN_CV "Use Intel's OpenCV library" OFF)
 
 IF(MITK_USE_OPEN_CV)
 
 #MESSAGE( STATUS "Creating Module mitkOpenCVVideoSupport" )
 
 # check if the operating system is windows. This command does not check wether the system is running on 32 or 64 bit
 IF(WIN32)
   OPTION(MITK_USE_VIDEOINPUT_LIB "Use videoInput (DirectShow wrapper) library" OFF)
 
   IF(MITK_USE_VIDEOINPUT_LIB)
     SET( VIDEOINPUT_LIB "" CACHE FILEPATH "Search for the videoInput.lib file" )
     SET( VIDEOINPUT_HEADER_DIR "" CACHE PATH "The path containing VideoInput.h" )
     IF(CMAKE_CL_64)
       SET( STRMBASD_LIB "" CACHE FILEPATH "Search for the strmbasd.lib file. Provided by DirectShow, if not found, download Microsoft Platform SDK and go to the Samples_Multimedia_DirectShow_BaseClasses folder and compile the BaseClasses solution to generate the strmbasd.lib. Place it in the same folder as the videoInput.lib")
     ENDIF(CMAKE_CL_64)    
     SET( CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} /NODEFAULTLIB:LIBCMT /NODEFAULTLIB:atlthunk" )
     SET( OPENCVVIDEOSUPPORT_ADDITIONAL_LIBS ${VIDEOINPUT_LIB} ${STRMBASD_LIB} )
     INCLUDE_DIRECTORIES( ${VIDEOINPUT_HEADER_DIR} )
     ADD_DEFINITIONS(-DMITK_USE_VIDEOINPUT_LIB)
   ENDIF(MITK_USE_VIDEOINPUT_LIB)
 
  ELSE(WIN32)
   SET(MITK_USE_VIDEOINPUT_LIB OFF)
 ENDIF(WIN32)
 
   MITK_CREATE_MODULE(mitkOpenCVVideoSupport
     DEPENDS Mitk MitkExt
     PACKAGE_DEPENDS OpenCV
     PROVIDES mitkOpenCVVideoSupport
     ADDITIONAL_LIBS ${OPENCVVIDEOSUPPORT_ADDITIONAL_LIBS}
     EXPORT_DEFINE MITK_OPENCVVIDEOSUPPORT_EXPORT
   )
   
   IF(MITK_USE_QT)
     ADD_SUBDIRECTORY(UI)
   ENDIF(MITK_USE_QT)  
     
   IF(BUILD_TESTING)
     ADD_SUBDIRECTORY(Testing)
   ENDIF(BUILD_TESTING)  
   
 ELSE(MITK_USE_OPEN_CV)
 
     MESSAGE( STATUS "Not creating Module mitkOpenCVVideoSupport" )
 
 ENDIF(MITK_USE_OPEN_CV)
 
diff --git a/SuperBuild.cmake b/SuperBuild.cmake
index adb8f0841a..c3a20ac842 100644
--- a/SuperBuild.cmake
+++ b/SuperBuild.cmake
@@ -1,232 +1,231 @@
 
 #-----------------------------------------------------------------------------
 # Convenient macro allowing to download a file
 #-----------------------------------------------------------------------------
 
 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
 #-----------------------------------------------------------------------------
 
 #----------------------------- Qt ---------------------------
 if(MITK_USE_QT)
   find_package(Qt4 REQUIRED)
   set(vtk_QT_ARGS
       -DDESIRED_QT_VERSION:STRING=4
       -DVTK_USE_GUISUPPORT:BOOL=ON
       -DVTK_USE_QVTK_QTOPENGL:BOOL=ON
       -DVTK_USE_QT:BOOL=ON
       -DQT_QMAKE_EXECUTABLE:FILEPATH=${QT_QMAKE_EXECUTABLE}
      )
 endif()
 
 #-----------------------------------------------------------------------------
 # External project settings
 #-----------------------------------------------------------------------------
 
 INCLUDE(ExternalProject)
 
 SET(ep_base "${CMAKE_BINARY_DIR}/CMakeExternals")
 SET_PROPERTY(DIRECTORY PROPERTY EP_BASE ${ep_base})
 
 SET(ep_install_dir ${ep_base}/Install)
 #SET(ep_build_dir ${ep_base}/Build)
 #SET(ep_source_dir ${ep_base}/Source)
 #SET(ep_parallelism_level)
 SET(ep_build_shared_libs ON)
 SET(ep_build_testing OFF)
 
 # 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(MSVC90 OR MSVC10)
   SET(ep_common_C_FLAGS "${CMAKE_C_FLAGS} /bigobj /MP")
   SET(ep_common_CXX_FLAGS "${CMAKE_CXX_FLAGS} /bigobj /MP")
 ELSE()
   SET(ep_common_C_FLAGS "${CMAKE_C_FLAGS} -DLINUX_EXTRA")
   SET(ep_common_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DLINUX_EXTRA")
 ENDIF()
 
 SET(ep_common_args 
   -DBUILD_TESTING:BOOL=${ep_build_testing}
   -DCMAKE_INSTALL_PREFIX:PATH=${ep_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=${ep_common_C_FLAGS}
   -DCMAKE_CXX_FLAGS:STRING=${ep_common_CXX_FLAGS}
   #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}
 )
 
 #-----------------------------------------------------------------------------
 # ExternalProjects 
 #-----------------------------------------------------------------------------
 
 SET(external_projects
   VTK
   GDCM
   ITK
   Boost
   DCMTK
   CTK
+  OpenCV
   )
   
 # Include external projects
 FOREACH(p ${external_projects})
   INCLUDE(CMakeExternals/${p}.cmake)
 ENDFOREACH()
 
 #-----------------------------------------------------------------------------
 # Set superbuild boolean args
 #-----------------------------------------------------------------------------
 
 SET(mitk_cmake_boolean_args
   BUILD_SHARED_LIBS
   WITH_COVERAGE
   BUILD_TESTING
   
   MITK_USE_QT
   MITK_INSTALL_RPATH_RELATIVE
   MITK_BUILD_ALL_PLUGINS
   MITK_BUILD_TUTORIAL
   MITK_USE_Boost
   MITK_USE_GDCMIO
   MITK_USE_BLUEBERRY
   MITK_USE_CTK
-  MITK_USE_DCMTK  
+  MITK_USE_DCMTK
+  MITK_USE_OPEN_CV
   )
   
 #-----------------------------------------------------------------------------
 # Generate cmake variable names for MITK bundles
 #-----------------------------------------------------------------------------
 
 INCLUDE(mitkSuperBuildPlugins)
 FOREACH(plugin ${MITK_SUPERBUILD_PLUGINS})
   LIST(APPEND mitk_cmake_boolean_args MITK_BUILD_${plugin})
   OPTION(MITK_BUILD_${plugin} "Build the MITK ${plugin} plugin" OFF)
 ENDFOREACH()
 
 #-----------------------------------------------------------------------------
 # 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
     # Mandatory dependencies
     ${VTK_DEPENDS}
     ${ITK_DEPENDS}
     # Optionnal dependencies
     ${Boost_DEPENDS}
     ${CTK_DEPENDS}
     ${DCMTK_DEPENDS}
     
 )
 
 #-----------------------------------------------------------------------------
 # MITK Configure
 #-----------------------------------------------------------------------------
 
 SET(proj MITK-Configure)
 
 ExternalProject_Add(${proj}
   DOWNLOAD_COMMAND ""
   CMAKE_GENERATOR ${gen}
   CMAKE_ARGS
     ${ep_common_args}
     ${mitk_superbuild_boolean_args}
     -DMITK_USE_SUPERBUILD:BOOL=OFF
     -DCTEST_USE_LAUNCHERS:BOOL=${CTEST_USE_LAUNCHERS}
     -DMITK_SUPERBUILD_BINARY_DIR:PATH=${MITK_BINARY_DIR}
     -DQT_QMAKE_EXECUTABLE:FILEPATH=${QT_QMAKE_EXECUTABLE}
     -DMITK_KWSTYLE_EXECUTABLE:FILEPATH=${MITK_KWSTYLE_EXECUTABLE}
     -DCTK_DIR:PATH=${CTK_DIR} 
     -DDCMTK_DIR:PATH=${DCMTK_DIR}
     -DVTK_DIR:PATH=${VTK_DIR}     # FindVTK expects VTK_DIR
     -DITK_DIR:PATH=${ITK_DIR}     # FindITK expects ITK_DIR
+    -DOpenCV_DIR:PATH=${OpenCV_DIR}
     -DGDCM_DIR:PATH=${GDCM_DIR}
     -DBOOST_ROOT:PATH=${BOOST_ROOT}
-    -DMITK_USE_Boost:BOOL=${MITK_USE_Boost}
-    -DMITK_USE_GDCMIO:BOOL=${MITK_USE_GDCMIO}
-    -DMITK_USE_DCMTK:BOOL=${MITK_USE_DCMTK}
-    -DMITK_USE_QT:BOOL=${MITK_USE_QT}
 
   SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}
   BINARY_DIR ${CMAKE_BINARY_DIR}/MITK-build
   BUILD_COMMAND ""
   INSTALL_COMMAND ""
   DEPENDS
     MITK-Utilities
   )
 
 
 #-----------------------------------------------------------------------------
 # MITK
 #-----------------------------------------------------------------------------
 
 #MESSAGE(STATUS SUPERBUILD_EXCLUDE_MITKBUILD_TARGET:${SUPERBUILD_EXCLUDE_MITKBUILD_TARGET})
 IF(NOT DEFINED SUPERBUILD_EXCLUDE_MITKBUILD_TARGET OR NOT SUPERBUILD_EXCLUDE_MITKBUILD_TARGET)
   SET(proj MITK-build)
   ExternalProject_Add(${proj}
     DOWNLOAD_COMMAND ""
     CMAKE_GENERATOR ${gen}
     SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}
     BINARY_DIR MITK-build
     INSTALL_COMMAND ""
     DEPENDS
       "MITK-Configure"
     )
 ENDIF()
 
 #-----------------------------------------------------------------------------
 # Custom target allowing to drive the build of MITK project itself
 #-----------------------------------------------------------------------------
 
 ADD_CUSTOM_TARGET(MITK
   COMMAND ${CMAKE_COMMAND} --build ${CMAKE_CURRENT_BINARY_DIR}/MITK-build
   WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/MITK-build
 )