diff --git a/CMake/mitkMacroCreateModuleTests.cmake b/CMake/mitkMacroCreateModuleTests.cmake
index 4f2eb1e30a..4f1f5f06f8 100644
--- a/CMake/mitkMacroCreateModuleTests.cmake
+++ b/CMake/mitkMacroCreateModuleTests.cmake
@@ -1,85 +1,85 @@
 #
 # Create tests and testdriver for this module
 # 
 # Usage: MITK_CREATE_MODULE_TESTS( [EXTRA_DRIVER_INIT init_code]  )
 # 
 # EXTRA_DRIVER_INIT is inserted as c++ code in the testdriver and will be executed before each test
 #
 MACRO(MITK_CREATE_MODULE_TESTS)
   MACRO_PARSE_ARGUMENTS(MODULE_TEST 
                         "EXTRA_DRIVER_INIT;EXTRA_DRIVER_INCLUDE" "" ${ARGN})
 
   IF(BUILD_TESTING AND MODULE_IS_ENABLED)
     SET(OLD_MOC_H_FILES ${MOC_H_FILES})
     SET(MOC_H_FILES)
     INCLUDE(files.cmake)
     INCLUDE_DIRECTORIES(.)
     
     IF(DEFINED MOC_H_FILES)
       QT4_WRAP_CPP(MODULE_TEST_GENERATED_MOC_CPP ${MOC_H_FILES})
     ENDIF(DEFINED MOC_H_FILES)
      
     SET(CMAKE_TESTDRIVER_BEFORE_TESTMAIN "mitk::LoggingBackend::Register(); ${MODULE_TEST_EXTRA_DRIVER_INIT};")
     SET(CMAKE_TESTDRIVER_AFTER_TESTMAIN "mitk::LoggingBackend::Unregister();")
     IF(NOT MODULE_TEST_EXTRA_DRIVER_INCLUDE)
       # this is necessary to make the LoggingBackend calls available if nothing else is included
       SET(MODULE_TEST_EXTRA_DRIVER_INCLUDE "mitkLog.h")
     ENDIF(NOT MODULE_TEST_EXTRA_DRIVER_INCLUDE)
     
     CREATE_TEST_SOURCELIST(MODULETEST_SOURCE ${MODULE_NAME}TestDriver.cpp 
       ${MODULE_TESTS} ${MODULE_IMAGE_TESTS} ${MODULE_CUSTOM_TESTS}
       EXTRA_INCLUDE ${MODULE_TEST_EXTRA_DRIVER_INCLUDE}
     )
     
     SET(TESTDRIVER ${MODULE_NAME}TestDriver)
     ADD_EXECUTABLE(${TESTDRIVER} ${MODULETEST_SOURCE} ${MODULE_TEST_GENERATED_MOC_CPP})
     TARGET_LINK_LIBRARIES(${TESTDRIVER} ${MODULE_PROVIDES} ${ALL_LIBRARIES})
     
     IF(MODULE_SUBPROJECTS)
       FOREACH(subproject ${MODULE_SUBPROJECTS})
         ADD_DEPENDENCIES(${subproject} ${TESTDRIVER})
       ENDFOREACH()
     ENDIF()
     
     #
     # Now tell CMake which tests should be run. This is done automatically 
     # for all tests in ${KITNAME}_TESTS and ${KITNAME}_IMAGE_TESTS. The IMAGE_TESTS
     # are run for each image in the TESTIMAGES list.
     #
     FOREACH( test ${MODULE_TESTS} )
       GET_FILENAME_COMPONENT(TName ${test} NAME_WE)
       ADD_TEST(${TName} ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${TESTDRIVER} ${TName})
       # Add labels for CDash subproject support
       IF(MODULE_SUBPROJECTS)
         SET_PROPERTY(TEST ${TName} PROPERTY LABELS ${MODULE_SUBPROJECTS} MITK)
       ENDIF()
     ENDFOREACH( test )
 
     FOREACH(image ${MODULE_TESTIMAGES} ${ADDITIONAL_TEST_IMAGES} )
       IF(EXISTS ${image})
         SET(IMAGE_FULL_PATH ${image})
       ELSE(EXISTS ${image})
         # todo: maybe search other paths as well
         # yes, please in mitk/Testing/Data, too
-        SET(IMAGE_FULL_PATH ${MITK_SOURCE_DIR}/Core/Code/Testing/Data/${image})
+        SET(IMAGE_FULL_PATH ${MITK_DATA_DIR}/${image})
       ENDIF(EXISTS ${image})
 
       IF(EXISTS ${IMAGE_FULL_PATH})
         FOREACH( test ${MODULE_IMAGE_TESTS} )
           GET_FILENAME_COMPONENT(TName ${test} NAME_WE)
           GET_FILENAME_COMPONENT(ImageName ${IMAGE_FULL_PATH} NAME)
           ADD_TEST(${TName}_${ImageName} ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${TESTDRIVER} ${TName} ${IMAGE_FULL_PATH})
           # Add labels for CDash subproject support
           IF(MODULE_SUBPROJECTS)
-            SET_PROPERTY(TEST ${TName} PROPERTY LABELS ${MODULE_SUBPROJECTS} MITK)
+            SET_PROPERTY(TEST ${TName}_${ImageName} PROPERTY LABELS ${MODULE_SUBPROJECTS} MITK)
           ENDIF()
         ENDFOREACH( test )
       ELSE(EXISTS ${IMAGE_FULL_PATH})
         MESSAGE("!!!!! No such file: ${IMAGE_FULL_PATH} !!!!!")
       ENDIF(EXISTS ${IMAGE_FULL_PATH})
     ENDFOREACH( image )
 
     SET(MOC_H_FILES ${OLD_MOC_H_FILES})
   ENDIF(BUILD_TESTING AND MODULE_IS_ENABLED)
 
 ENDMACRO(MITK_CREATE_MODULE_TESTS)
diff --git a/CMakeExternals/MITKData.cmake b/CMakeExternals/MITKData.cmake
new file mode 100644
index 0000000000..a77157e730
--- /dev/null
+++ b/CMakeExternals/MITKData.cmake
@@ -0,0 +1,34 @@
+#-----------------------------------------------------------------------------
+# MITK Data
+#-----------------------------------------------------------------------------
+
+# Sanity checks
+IF(DEFINED MITK_DATA_DIR AND NOT EXISTS ${MITK_DATA_DIR})
+  MESSAGE(FATAL_ERROR "MITK_DATA_DIR variable is defined but corresponds to non-existing directory")
+ENDIF()
+
+SET(MITK-Data_DEPENDS)
+
+IF(BUILD_TESTING)
+  SET(proj MITK-Data)
+  SET(proj_DEPENDENCIES)
+  SET(MITK-Data_DEPENDS ${proj})
+
+  ExternalProject_Add(${proj}
+    GIT_REPOSITORY http://mbits/git/MITK-Data.git
+    GIT_TAG "origin/master"
+    CONFIGURE_COMMAND ""
+    BUILD_COMMAND ""
+    INSTALL_COMMAND ""
+    DEPENDS ${proj_DEPENDENCIES}
+  )
+  
+  SET(MITK_DATA_DIR ${ep_source_dir}/${proj})
+  
+ELSE()
+
+  mitkMacroEmptyExternalProject(${proj} "${proj_DEPENDENCIES}")
+  
+ENDIF(BUILD_TESTING)
+
+ 
diff --git a/MITKConfig.cmake.in b/MITKConfig.cmake.in
index 7e77900279..6c2706dba6 100644
--- a/MITKConfig.cmake.in
+++ b/MITKConfig.cmake.in
@@ -1,115 +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@")
 SET(MITK_EXPORTS_FILE "@MITK_EXPORTS_FILE@")
 
 # 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(MITK_QMAKE_EXECUTABLE "@QT_QMAKE_EXECUTABLE@")
 SET(MITK_INSTALL_RPATH_RELATIVE @MITK_INSTALL_RPATH_RELATIVE@)
+SET(MITK_DATA_DIR "@MITK_DATA_DIR@")
 
 # 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@)
 
 # 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/SuperBuild.cmake b/SuperBuild.cmake
index 30f20d8a41..50efa36a7b 100644
--- a/SuperBuild.cmake
+++ b/SuperBuild.cmake
@@ -1,232 +1,234 @@
 
 #-----------------------------------------------------------------------------
 # 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_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
+  MITKData
   )
   
 # 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  
   )
   
 #-----------------------------------------------------------------------------
 # 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-Data_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
     -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}
+    -DMITK_DATA_DIR:PATH=${MITK_DATA_DIR}
 
   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
 )