diff --git a/Applications/CoreApp/CMakeLists.txt b/Applications/CoreApp/CMakeLists.txt index 2202d16166..8044c1c25d 100644 --- a/Applications/CoreApp/CMakeLists.txt +++ b/Applications/CoreApp/CMakeLists.txt @@ -1,60 +1,66 @@ FIND_PACKAGE(BlueBerry REQUIRED) INCLUDE_DIRECTORIES( ${BLUEBERRY_PLUGIN_SOURCE_DIRS} ${org.blueberry.osgi_BIN_DIR} # needed for generated berryConfig.h ${Poco_INCLUDE_DIRS} ) LINK_DIRECTORIES(${Poco_LIBRARY_DIRS} ${BLUEBERRY_PLUGINS_OUTPUT_DIR}/org.blueberry.osgi/bin ) IF(MITK_SHOW_CONSOLE_WINDOW) ADD_EXECUTABLE(CoreApp MACOSX_BUNDLE CoreApp.cpp) ELSE(MITK_SHOW_CONSOLE_WINDOW) ADD_EXECUTABLE(CoreApp MACOSX_BUNDLE WIN32 CoreApp.cpp) ENDIF(MITK_SHOW_CONSOLE_WINDOW) IF (WIN32) FIND_PACKAGE(Qt4) TARGET_LINK_LIBRARIES(CoreApp ${QT_QTCORE_LIBRARY} ${QT_QTMAIN_LIBRARY}) ENDIF(WIN32) TARGET_LINK_LIBRARIES(CoreApp optimized PocoFoundation debug PocoFoundationd optimized PocoUtil debug PocoUtild optimized org_blueberry_osgi debug org_blueberry_osgi${BLUEBERRY_DEBUG_POSTFIX}) SET_TARGET_PROPERTIES(CoreApp PROPERTIES INSTALL_RPATH "${CMAKE_INSTALL_RPATH};${CMAKE_INSTALL_RPATH}/BlueBerry/org.blueberry.osgi/bin") +# subproject support +ADD_DEPENDENCIES(MITK-CoreUI CoreApp) +IF(MITK_ENABLE_GUI_TESTING) + ADD_DEPENDENCIES(MITK-CoreUI solstice) +ENDIF() + SET(_plugin_deps ${BLUEBERRY_ENABLED_PLUGINS} ${MITK_CORE_ENABLED_PLUGINS} ${MITK_CORE_ENABLED_TEST_PLUGINS} ) IF(_plugin_deps) # Make sure all enabled plug-ins are up to date ADD_DEPENDENCIES(CoreApp ${_plugin_deps}) ENDIF() SET(BLUEBERRY_PLUGIN_CACHE_DIR "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/plugin_cache") CONFIGURE_FILE(CoreApp.ini ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/CoreApp.ini) IF(WIN32) FOREACH(COREAPP_BUILD_TYPE debug release) mitkFunctionCreateWindowsBatchScript(startCoreApp.bat.in ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/startCoreApp_${COREAPP_BUILD_TYPE}.bat ${COREAPP_BUILD_TYPE}) ENDFOREACH() ENDIF(WIN32) MITK_INSTALL_TARGETS(EXECUTABLES CoreApp GLOB_PLUGINS ) IF(UNIX AND MITK_INSTALL_RPATH_RELATIVE AND NOT APPLE) INSTALL(PROGRAMS "${MITK_SOURCE_DIR}/CMake/RunInstalledApp.sh" DESTINATION "." RENAME CoreApp.sh) ENDIF() SET(MITK_CPACK_PACKAGE_EXECUTABLES ${MITK_CPACK_PACKAGE_EXECUTABLES} "CoreApp;MITK - CoreApp Application" CACHE INTERNAL "Collecting windows shortcuts to executables") diff --git a/BlueBerry/Bundles/CMakeLists.txt b/BlueBerry/Bundles/CMakeLists.txt index 8990e1e3c0..7e6e6fc6bf 100755 --- a/BlueBerry/Bundles/CMakeLists.txt +++ b/BlueBerry/Bundles/CMakeLists.txt @@ -1,18 +1,23 @@ SET(_default_plugins org.blueberry.osgi org.blueberry.solstice.common org.blueberry.core.runtime org.blueberry.core.expressions org.blueberry.core.commands org.blueberry.ui org.blueberry.ui.qt ) MACRO_COLLECT_PLUGINS(OUTPUT_DIR ${BLUEBERRY_PLUGINS_OUTPUT_DIR} CACHE_PLUGIN_TARGETS BLUEBERRY_ENABLED_PLUGINS BUNDLE_LIST_PATH "${BLUEBERRY_BINARY_DIR}/BlueBerryBundleList.cmake" CMAKE_CACHE_PREFIX "BLUEBERRY" PLUGIN_DEFAULT_ON ${_default_plugins} ${BLUEBERRY_BUILD_ALL_PLUGINS_OPTION}) - \ No newline at end of file + +add_dependencies(BlueBerry ${BLUEBERRY_ENABLED_PLUGINS}) +foreach(plugin ${BLUEBERRY_ENABLED_PLUGINS}) + string(REPLACE "." "_" plugin_target ${plugin}) + set_property(TARGET ${plugin_target} PROPERTY LABELS BlueBerry) +endforeach() diff --git a/BlueBerry/Bundles/org.blueberry.osgi/CMakeLists.txt b/BlueBerry/Bundles/org.blueberry.osgi/CMakeLists.txt index 528543ed1f..b6422387d8 100644 --- a/BlueBerry/Bundles/org.blueberry.osgi/CMakeLists.txt +++ b/BlueBerry/Bundles/org.blueberry.osgi/CMakeLists.txt @@ -1,25 +1,27 @@ CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/src/berryConfig.h.in" "${CMAKE_CURRENT_BINARY_DIR}/berryConfig.h" @ONLY) MACRO_CREATE_PLUGIN() TARGET_LINK_LIBRARIES(${PLUGIN_TARGET} optimized PocoUtil debug PocoUtild optimized PocoXML debug PocoXMLd) ADD_EXECUTABLE(${OSGI_APP} MACOSX_BUNDLE "src/application/berryMain.cpp") # ADD_EXECUTABLE(${OSGI_APP} "src/application/berryMain.cpp") TARGET_LINK_LIBRARIES(${OSGI_APP} ${PLUGIN_TARGET} mbilog) IF (BLUEBERRY_ENABLED_TEST_PLUGINS) ADD_DEPENDENCIES(${OSGI_APP} ${BLUEBERRY_ENABLED_TEST_PLUGINS}) + ADD_DEPENDENCIES(BlueBerry ${OSGI_APP}) + SET_PROPERTY(TARGET ${OSGI_APP} APPEND PROPERTY LABELS BlueBerry) ENDIF() SET(BLUEBERRY_PLUGIN_CACHE_DIR "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/plugin_cache") CONFIGURE_FILE(src/application/solstice.ini ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${OSGI_APP}.ini) SET_TARGET_PROPERTIES(${OSGI_APP} PROPERTIES INSTALL_RPATH "${CMAKE_INSTALL_RPATH};${CMAKE_INSTALL_PREFIX}/bin/BlueBerry/org.blueberry.osgi/bin") # MITK_INSTALL_TARGETS(EXECUTABLES ${OSGI_APP} GLOB_PLUGINS ) # MITK_INSTALL_TARGETS(EXECUTABLES ${OSGI_APP} LIBRARY_DIRS ${CMAKE_INSTALL_PREFIX}/bin) # MITK_INSTALL_TARGETS(EXECUTABLES ${OSGI_APP} LIBRARY_DIRS ${CMAKE_INSTALL_PREFIX}/bin PLUGINS ${CMAKE_INSTALL_PREFIX}/bin/BlueBerry/org.blueberry.osgi/bin/liborg_blueberry_osgid.dylib) diff --git a/BlueBerry/CMake/berryTestingHelpers.cmake b/BlueBerry/CMake/berryTestingHelpers.cmake index ec78382350..09c5adf96a 100755 --- a/BlueBerry/CMake/berryTestingHelpers.cmake +++ b/BlueBerry/CMake/berryTestingHelpers.cmake @@ -1,49 +1,61 @@ # Call this macro after calling MACRO_CREATE_PLUGIN in your CMakeLists.txt # # Variables: # # - BLUEBERRY_TEST_APP contains the name of the executable which will start the OSGi framework # MACRO(MACRO_TEST_PLUGIN) SET(_cla_switch "--") IF(WIN32) IF(MSYS) SET(_cla_switch "//") ELSE() SET(_cla_switch "/") ENDIF() ENDIF() ADD_TEST(${BUNDLE-SYMBOLICNAME} ${BLUEBERRY_TEST_APP} ${_cla_switch}BlueBerry.application=coretestapplication ${_cla_switch}BlueBerry.testplugin=${BUNDLE-SYMBOLICNAME}) + SET(_labels ${ARGN}) + IF(NOT _labels) + SET(_labels BlueBerry) + ENDIF() + SET_PROPERTY(TEST ${BUNDLE-SYMBOLICNAME} PROPERTY LABELS ${_labels}) + ENDMACRO(MACRO_TEST_PLUGIN) # Variables: # # - BLUEBERRY_TEST_APP contains the name of the executable which will start the OSGi framework # - BLUEBERRY_TEST_APP_ID contains the application id of the application to test. If empty, # a minimalistic default application will be started MACRO(MACRO_TEST_UIPLUGIN) SET(_cla_switch "--") IF(WIN32) IF(MSYS) SET(_cla_switch "//") ELSE() SET(_cla_switch "/") ENDIF() ENDIF() IF(BLUEBERRY_ENABLE_GUI_TESTING) IF(BLUEBERRY_TEST_APP_ID) SET(_app_id_arg "${_cla_switch}BlueBerry.testapplication=${BLUEBERRY_TEST_APP_ID}") ELSE() SET(_app_id_arg ) ENDIF() ADD_TEST(${BUNDLE-SYMBOLICNAME} ${BLUEBERRY_TEST_APP} ${_cla_switch}BlueBerry.application=uitestapplication ${_app_id_arg} ${_cla_switch}BlueBerry.testplugin=${BUNDLE-SYMBOLICNAME}) + + SET(_labels ${ARGN}) + IF(NOT _labels) + SET(_labels BlueBerry) + ENDIF() + SET_PROPERTY(TEST ${BUNDLE-SYMBOLICNAME} PROPERTY LABELS ${_labels}) ENDIF() ENDMACRO(MACRO_TEST_UIPLUGIN) diff --git a/BlueBerry/CMakeLists.txt b/BlueBerry/CMakeLists.txt index 86818d2bc2..26ceb416b6 100644 --- a/BlueBerry/CMakeLists.txt +++ b/BlueBerry/CMakeLists.txt @@ -1,187 +1,189 @@ PROJECT(BlueBerry) CMAKE_MINIMUM_REQUIRED(VERSION 2.6) SET(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_SOURCE_DIR}/CMake/") INCLUDE(MacroParseArguments) INCLUDE(MacroConvertSchema) INCLUDE(MacroOrganizeSources) INCLUDE(berryPluginHelpers) INCLUDE(MacroCollectPlugins) INCLUDE(MacroParseManifest) INCLUDE(MacroCreatePlugin) INCLUDE(MacroCreateQtHelp) INCLUDE(MacroInstallPlugin) OPTION(BLUEBERRY_INSTALL_RPATH_RELATIVE "Use relative rpath entries when installing" OFF) MARK_AS_ADVANCED(BLUEBERRY_INSTALL_RPATH_RELATIVE) IF(BLUEBERRY_INSTALL_RPATH_RELATIVE) SET(CMAKE_INSTALL_RPATH ".") ELSE() SET(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/bin") ENDIF() IF(MSVC) SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /wd4250 /wd4275 /wd4251 /wd4503") ENDIF() IF (NOT CMAKE_RUNTIME_OUTPUT_DIRECTORY) SET (CMAKE_RUNTIME_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/bin) ENDIF () FIND_PACKAGE(mbilog REQUIRED) INCLUDE_DIRECTORIES(${mbilog_INCLUDE_DIRS}) OPTION(BLUEBERRY_USE_QT "Use the Qt GUI toolkit" OFF) IF(NOT DESIRED_QT_VERSION) SET(DESIRED_QT_VERSION 4 CACHE STRING "Desired Qt version" FORCE) MARK_AS_ADVANCED(DESIRED_QT_VERSION) ENDIF() IF(BLUEBERRY_USE_QT AND NOT DESIRED_QT_VERSION EQUAL 4) MESSAGE("Attention: Qt4 is required to build the BlueBerry Qt plug-ins.") ENDIF() IF(BLUEBERRY_USE_QT AND DESIRED_QT_VERSION EQUAL 4) SET(QT_MT_REQUIRED 1) SET(BUILD_QT_PLUGINS 1) FIND_PACKAGE(Qt REQUIRED) IF(QT_QMAKE_CHANGED) SET(QT_HELPGENERATOR_EXECUTABLE NOTFOUND) SET(QT_COLLECTIONGENERATOR_EXECUTABLE NOTFOUND) SET(QT_ASSISTANT_EXECUTABLE NOTFOUND) ENDIF() FIND_PROGRAM(QT_HELPGENERATOR_EXECUTABLE NAMES qhelpgenerator qhelpgenerator-qt4 qhelpgenerator4 PATHS ${QT_BINARY_DIR} NO_DEFAULT_PATH ) FIND_PROGRAM(QT_COLLECTIONGENERATOR_EXECUTABLE NAMES qcollectiongenerator qcollectiongenerator-qt4 qcollectiongenerator4 PATHS ${QT_BINARY_DIR} NO_DEFAULT_PATH ) FIND_PROGRAM(QT_ASSISTANT_EXECUTABLE NAMES assistant-qt4 assistant4 assistant PATHS ${QT_BINARY_DIR} NO_DEFAULT_PATH ) OPTION(BLUEBERRY_USE_QT_HELP "Enable support for integrating bundle documentation into Qt Help" ON) MARK_AS_ADVANCED(BLUEBERRY_USE_QT_HELP QT_HELPGENERATOR_EXECUTABLE QT_COLLECTIONGENERATOR_EXECUTABLE QT_ASSISTANT_EXECUTABLE) SET(_doxygen_too_old 1) IF(BLUEBERRY_USE_QT_HELP) FIND_PACKAGE(Doxygen) IF(DOXYGEN_FOUND) EXECUTE_PROCESS(COMMAND ${DOXYGEN_EXECUTABLE} --version OUTPUT_VARIABLE _doxygen_version) IF(${_doxygen_version} VERSION_GREATER 1.6.0 OR ${_doxygen_version} VERSION_EQUAL 1.6.0) SET(_doxygen_too_old 0) ENDIF() ENDIF() ELSE(BLUEBERRY_USE_QT_HELP) CONFIGURE_FILE(../Documentation/pregenerated/MITKBlankPage.qch ${MITK_BINARY_DIR}/bin/ExtBundles/org.mitk.gui.qt.extapplication/resources/MITKBlankPage.qch COPYONLY) CONFIGURE_FILE(../Documentation/pregenerated/MitkExtQtHelpCollection.qhc ${MITK_BINARY_DIR}/bin/ExtBundles/org.mitk.gui.qt.extapplication/resources/MitkExtQtHelpCollection.qhc COPYONLY) ENDIF(BLUEBERRY_USE_QT_HELP) IF (BLUEBERRY_USE_QT_HELP AND _doxygen_too_old) MESSAGE("Doxygen was not found or is too old. Version 1.6.0 or later is needed if BLUEBERRY_USE_QT_HELP is ON") SET(BLUEBERRY_USE_QT_HELP OFF CACHE BOOL "Enable support for integrating bundle documentation into Qt Help" FORCE) ENDIF() IF(BLUEBERRY_USE_QT_HELP AND NOT QT_HELPGENERATOR_EXECUTABLE) MESSAGE("You have enabled Qt Help support, but QT_HELPGENERATOR_EXECUTABLE is empty") SET(BLUEBERRY_USE_QT_HELP OFF CACHE BOOL "Enable support for integrating bundle documentation into Qt Help" FORCE) ENDIF() INCLUDE(${QT_USE_FILE}) ENDIF() OPTION(BLUEBERRY_BUILD_ALL_PLUGINS "Build all BlueBerry plugins (overriding selection)" OFF) MARK_AS_ADVANCED(BLUEBERRY_BUILD_ALL_PLUGINS) IF(BLUEBERRY_BUILD_ALL_PLUGINS) SET(BLUEBERRY_BUILD_ALL_PLUGINS_OPTION "FORCE_BUILD_ALL") ENDIF() OPTION(BLUEBERRY_STATIC "Build all plugins as static libraries" OFF) MARK_AS_ADVANCED(BLUEBERRY_STATIC) OPTION(BLUEBERRY_DEBUG_SMARTPOINTER "Enable code for debugging smart pointers" OFF) MARK_AS_ADVANCED(BLUEBERRY_DEBUG_SMARTPOINTER) FIND_PACKAGE(Poco REQUIRED) FIND_PACKAGE(Ant) FIND_PACKAGE(Eclipse) SET(BLUEBERRY_SOURCE_DIR ${BlueBerry_SOURCE_DIR}) SET(BLUEBERRY_BINARY_DIR ${BlueBerry_BINARY_DIR}) SET(BLUEBERRY_PLUGINS_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/Bundles) SET(BLUEBERRY_PLUGINS_BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR}/Bundles) SET(OSGI_APP solstice) # Force should be removed after everybody has configured their old binary tree SET(BLUEBERRY_PLUGINS_OUTPUT_DIR ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/BlueBerry CACHE PATH "Directory where to build the BlueBerry Bundles" FORCE) MARK_AS_ADVANCED(BLUEBERRY_PLUGINS_OUTPUT_DIR) SET(BLUEBERRY_TEST_PLUGINS_OUTPUT_DIR ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/BlueBerryTests CACHE PATH "Directory where to build the BlueBerry test bundles") MARK_AS_ADVANCED(BLUEBERRY_TEST_PLUGINS_OUTPUT_DIR) # Clear the cache variables SET(BLUEBERRY_PLUGIN_SOURCE_DIRS "" CACHE INTERNAL "List of base plugin source directories" FORCE) SET(BLUEBERRY_PLUGIN_BINARY_DIRS "" CACHE INTERNAL "List of base plugin binary directories" FORCE) IF (Eclipse_DIR) SET(BLUEBERRY_DOC_TOOLS_DIR "${Eclipse_DIR}" CACHE PATH "Directory containing additional tools needed for generating the documentation") ELSE () SET(BLUEBERRY_DOC_TOOLS_DIR "" CACHE PATH "Directory containing additional tools needed for generating the documentation") ENDIF () SET(BLUEBERRY_DEBUG_POSTFIX d) +ADD_CUSTOM_TARGET(BlueBerry) + CONFIGURE_FILE(BlueBerryConfig.cmake.in ${CMAKE_CURRENT_BINARY_DIR}/BlueBerryConfig.cmake @ONLY) ADD_SUBDIRECTORY(Bundles) ADD_SUBDIRECTORY(Documentation) # Testing options OPTION(BLUEBERRY_BUILD_TESTING "Build the BlueBerry tests." OFF) IF(WIN32) SET(_gui_testing_default "ON") ELSE() SET(_gui_testing_default "OFF") ENDIF() OPTION(BLUEBERRY_ENABLE_GUI_TESTING "Enable the BlueBerry GUI tests" ${_gui_testing_default}) MARK_AS_ADVANCED(BLUEBERRY_ENABLE_GUI_TESTING) IF(BLUEBERRY_BUILD_TESTING) ENABLE_TESTING() ADD_SUBDIRECTORY(Testing) ENDIF() diff --git a/BlueBerry/Testing/CMakeLists.txt b/BlueBerry/Testing/CMakeLists.txt index 1afc1299e3..077bfbee0b 100755 --- a/BlueBerry/Testing/CMakeLists.txt +++ b/BlueBerry/Testing/CMakeLists.txt @@ -1,15 +1,22 @@ INCLUDE(berryTestingHelpers) INCLUDE(${BLUEBERRY_BINARY_DIR}/BlueBerryBundleList.cmake) SET(BLUEBERRY_TEST_APP "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${OSGI_APP}") GET_TARGET_PROPERTY(_is_macosx_bundle ${OSGI_APP} MACOSX_BUNDLE) IF(APPLE AND _is_macosx_bundle) SET(BLUEBERRY_TEST_APP "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${OSGI_APP}.app/Contents/MacOS/${OSGI_APP}") ENDIF() +SET(PLUGIN_EXCLUDE_LIST ) +IF(NOT BLUEBERRY_ENABLE_GUI_TESTING) + LIST(APPEND PLUGIN_EXCLUDE_LIST org.blueberry.ui.tests) +ENDIF() + MACRO_COLLECT_PLUGINS(OUTPUT_DIR ${BLUEBERRY_TEST_PLUGINS_OUTPUT_DIR} CACHE_PLUGIN_TARGETS BLUEBERRY_ENABLED_TEST_PLUGINS BUNDLE_LIST_PATH "${BLUEBERRY_BINARY_DIR}/BlueBerryTestBundleList.cmake" CMAKE_CACHE_PREFIX "BLUEBERRY_TEST" + PLUGIN_EXCLUDES ${PLUGIN_EXCLUDE_LIST} ${BLUEBERRY_BUILD_ALL_PLUGINS_OPTION}) + diff --git a/CMake/MITKDashboardDriverScript.cmake b/CMake/MITKDashboardDriverScript.cmake new file mode 100644 index 0000000000..30bc1e28be --- /dev/null +++ b/CMake/MITKDashboardDriverScript.cmake @@ -0,0 +1,448 @@ + +# +# Included from a dashboard script, this cmake file will drive the configure and build +# steps of MITK +# + +#----------------------------------------------------------------------------- +# The following variable are expected to be define in the top-level script: +set(expected_variables + ADDITIONNAL_CMAKECACHE_OPTION + CTEST_NOTES_FILES + CTEST_SITE + CTEST_DASHBOARD_ROOT + CTEST_CMAKE_COMMAND + CTEST_CMAKE_GENERATOR + WITH_MEMCHECK + WITH_COVERAGE + WITH_DOCUMENTATION + CTEST_BUILD_CONFIGURATION + CTEST_TEST_TIMEOUT + CTEST_BUILD_FLAGS + TEST_TO_EXCLUDE_REGEX + CTEST_SOURCE_DIRECTORY + CTEST_BINARY_DIRECTORY + CTEST_BUILD_NAME + SCRIPT_MODE + CTEST_COVERAGE_COMMAND + CTEST_MEMORYCHECK_COMMAND + CTEST_GIT_COMMAND + QT_QMAKE_EXECUTABLE + PROJECT_BUILD_DIR + SUPERBUILD_TARGETS + ) +if(WITH_DOCUMENTATION) + list(APPEND expected_variables DOCUMENTATION_ARCHIVES_OUTPUT_DIRECTORY) +endif() + +foreach(var ${expected_variables}) + if(NOT DEFINED ${var}) + message(FATAL_ERROR "Variable ${var} should be defined in top-level script !") + endif() +endforeach() + +if (NOT DEFINED GIT_BRANCH OR GIT_BRANCH STREQUAL "") + set(GIT_BRANCH "") +else() + set(GIT_BRANCH "-b ${GIT_BRANCH}") +endif() + +# Should binary directory be cleaned? +set(empty_binary_directory FALSE) + +# Attempt to build and test also if 'ctest_update' returned an error +set(force_build FALSE) + +# Set model options +set(model "") +if (SCRIPT_MODE STREQUAL "experimental") + set(empty_binary_directory FALSE) + set(force_build TRUE) + set(model Experimental) +elseif (SCRIPT_MODE STREQUAL "continuous") + set(empty_binary_directory FALSE) + set(force_build FALSE) + set(model Continuous) +elseif (SCRIPT_MODE STREQUAL "nightly") + set(empty_binary_directory TRUE) + set(force_build TRUE) + set(model Nightly) +else() + message(FATAL_ERROR "Unknown script mode: '${SCRIPT_MODE}'. Script mode should be either 'experimental', 'continuous' or 'nightly'") +endif() + +#message("script_mode:${SCRIPT_MODE}") +#message("model:${model}") +#message("empty_binary_directory:${empty_binary_directory}") +#message("force_build:${force_build}") + +set(CTEST_USE_LAUNCHERS 1) + +if(NOT DARTCLIENT_ERROR_FILE) + set(DARTCLIENT_ERROR_FILE "${CTEST_BINARY_DIRECTORY}/dartclient_error.txt") +endif() + +if(empty_binary_directory) + message("Directory ${CTEST_BINARY_DIRECTORY} cleaned !") + ctest_empty_binary_directory(${CTEST_BINARY_DIRECTORY}) +endif() + +if(NOT DEFINED CTEST_CHECKOUT_DIR) + set(CTEST_CHECKOUT_DIR ${CTEST_SOURCE_DIRECTORY}) +endif() + +if(NOT EXISTS "${CTEST_CHECKOUT_DIR}") + set(CTEST_CHECKOUT_COMMAND "\"${CTEST_GIT_COMMAND}\" clone ${GIT_BRANCH} ${GIT_REPOSITORY} \"${CTEST_CHECKOUT_DIR}\"") +endif() + +set(CTEST_UPDATE_TYPE "git") +set(CTEST_UPDATE_COMMAND "${CTEST_GIT_COMMAND}") + +# +# run_ctest macro +# +MACRO(run_ctest) + set(dartclient_error) + + ctest_start(${model}) + ctest_update(SOURCE "${CTEST_CHECKOUT_DIR}" RETURN_VALUE res) + + if(COMMAND MITK_OVERRIDE_FORCE_BUILD) + MITK_OVERRIDE_FORCE_BUILD(force_build) + endif() + + # force a build if this is the first run and the build dir is empty + if(NOT EXISTS "${CTEST_BINARY_DIRECTORY}/CMakeCache.txt") + message("First time build - Initialize CMakeCache.txt") + set(res 1) + + # Write initial cache. + file(WRITE "${CTEST_BINARY_DIRECTORY}/CMakeCache.txt" " +CTEST_USE_LAUNCHERS:BOOL=${CTEST_USE_LAUNCHERS} +BUILD_TESTING:BOOL=TRUE +BLUEBERRY_BUILD_TESTING:BOOL=TRUE +BLUEBERRY_BUILD_ALL_PLUGINS:BOOL=TRUE +MITK_BUILD_ALL_PLUGINS:BOOL=TRUE +MITK_CTEST_SCRIPT_MODE:BOOL=TRUE +CMAKE_BUILD_TYPE:STRING=${CTEST_BUILD_CONFIGURATION} +QT_QMAKE_EXECUTABLE:FILEPATH=${QT_QMAKE_EXECUTABLE} +SUPERBUILD_EXCLUDE_MITKBUILD_TARGET:BOOL=TRUE +WITH_COVERAGE:BOOL=${WITH_COVERAGE} +#DOCUMENTATION_TARGET_IN_ALL:BOOL=${WITH_DOCUMENTATION} +DOCUMENTATION_ARCHIVES_OUTPUT_DIRECTORY:PATH=${DOCUMENTATION_ARCHIVES_OUTPUT_DIRECTORY} +${ADDITIONNAL_CMAKECACHE_OPTION} +") + endif() + + if(NOT dartclient_error AND res LESS 0) + # update error + set(dartclient_error "Update or checkout error") + endif() + + if(res GREATER 0 OR force_build) + + ctest_submit(PARTS Update) + + message("----------- [ Configure SuperBuild ] -----------") + + set_property(GLOBAL PROPERTY SubProject SuperBuild) + set_property(GLOBAL PROPERTY Label SuperBuild) + + ctest_configure(BUILD "${CTEST_BINARY_DIRECTORY}" + OPTIONS "-DCTEST_USE_LAUNCHERS=${CTEST_USE_LAUNCHERS}" + RETURN_VALUE res + ) + + if(NOT dartclient_error AND res) + set(dartclient_error "SuperBuild configure error (code ${res})") + endif() + + ctest_read_custom_files("${CTEST_BINARY_DIRECTORY}") + ctest_submit(PARTS Configure) + ctest_submit(FILES "${CTEST_BINARY_DIRECTORY}/Project.xml") + + # To get CTEST_PROJECT_SUBPROJECTS and CTEST_PROJECT_EXTERNALS definition + include("${CTEST_BINARY_DIRECTORY}/CTestConfigSubProject.cmake") + + # Build top level (either all or the supplied targets at + # superbuild level + if(SUPERBUILD_TARGETS) + foreach(superbuild_target ${SUPERBUILD_TARGETS}) + message("----------- [ Build ${superbuild_target} - SuperBuild ] -----------") + set(CTEST_BUILD_TARGET "${superbuild_target}") + ctest_build(BUILD "${CTEST_BINARY_DIRECTORY}" APPEND + RETURN_VALUE res + NUMBER_ERRORS num_errors + NUMBER_WARNINGS num_warnings) + ctest_submit(PARTS Build) + + if(NOT dartclient_error AND res) + set(dartclient_error "Build error for ${superbuild_target} (code ${res}): Warnings ${num_warnings}, Errors ${num_errors}") + elseif(NOT dartclient_error AND num_warnings) + set(dartclient_error "Warnings for ${superbuild_target}: ${num_warnings}") + endif() + + # runs only tests that have a LABELS property matching "SuperBuild" + ctest_test( + BUILD "${CTEST_BINARY_DIRECTORY}" + INCLUDE_LABEL "SuperBuild" + PARALLEL_LEVEL 8 + EXCLUDE ${TEST_TO_EXCLUDE_REGEX} + RETURN_VALUE res + ) + + ctest_submit(PARTS Test) + + if(NOT dartclient_error AND res) + set(dartclient_error "Test failures for ${superbuild_target} (code ${res})") + endif() + endforeach() + + # HACK Unfortunately ctest_coverage ignores the build argument, back-up the original dirs + file(READ "${CTEST_BINARY_DIRECTORY}/CMakeFiles/TargetDirectories.txt" old_coverage_dirs) + + # explicitly build requested external projects as subprojects + foreach(external_project_with_build_dir ${CTEST_PROJECT_EXTERNALS}) + string(REPLACE "^^" ";" external_project_with_build_dir_list "${external_project_with_build_dir}") + list(GET external_project_with_build_dir_list 0 external_project) + list(GET external_project_with_build_dir_list 1 external_project_build_dir) + + set_property(GLOBAL PROPERTY SubProject ${external_project}) + set_property(GLOBAL PROPERTY Label ${external_project}) + message("----------- [ Build ${external_project} ] -----------") + + # Build target + set(CTEST_BUILD_TARGET "${external_project}") + ctest_build(BUILD "${CTEST_BINARY_DIRECTORY}" APPEND + RETURN_VALUE res + NUMBER_ERRORS num_errors + NUMBER_WARNINGS num_warnings) + ctest_submit(PARTS Build) + + if(NOT dartclient_error AND res) + set(dartclient_error "Build error for ${external_project} (code ${res}): Warnings ${num_warnings}, Errors ${num_errors}") + elseif(NOT dartclient_error AND num_warnings) + set(dartclient_error "Warnings for ${external_project}: ${num_warnings}") + endif() + + # HACK Unfortunately ctest_coverage ignores the build argument, try to force it... + file(READ "${CTEST_BINARY_DIRECTORY}/${external_project_build_dir}/CMakeFiles/TargetDirectories.txt" mitk_build_coverage_dirs) + file(APPEND "${CTEST_BINARY_DIRECTORY}/CMakeFiles/TargetDirectories.txt" "${mitk_build_coverage_dirs}") + + message("----------- [ Test ${external_project} ] -----------") + + # runs only tests that have a LABELS property matching "${external_project}" + ctest_test( + BUILD "${CTEST_BINARY_DIRECTORY}/${external_project_build_dir}" + APPEND + INCLUDE_LABEL "${external_project}" + PARALLEL_LEVEL 8 + EXCLUDE ${TEST_TO_EXCLUDE_REGEX} + RETURN_VALUE res + ) + + ctest_submit(PARTS Test) + + if(NOT dartclient_error AND res) + set(dartclient_error "Test failures for ${external_project} (code ${res})") + endif() + + # Coverage per external project + if (WITH_COVERAGE AND CTEST_COVERAGE_COMMAND) + message("----------- [ Coverage ${external_project} ] -----------") + ctest_coverage(BUILD "${CTEST_BINARY_DIRECTORY}/${external_project_build_dir}" LABELS "${external_project}") + ctest_submit(PARTS Coverage) + endif () + + #if (WITH_MEMCHECK AND CTEST_MEMORYCHECK_COMMAND) + # ctest_memcheck(BUILD "${build_dir}" INCLUDE_LABEL "${subproject}") + # ctest_submit(PARTS MemCheck) + #endif () + + # restore old coverage dirs + file(WRITE "${CTEST_BINARY_DIRECTORY}/CMakeFiles/TargetDirectories.txt" "${old_coverage_dirs}") + + endforeach() + + message("----------- [ Finish SuperBuild ] -----------") + else() + message("----------- [ Build SuperBuild ] -----------") + endif() + + # build everything at superbuild level which has not yet been built + set(CTEST_BUILD_TARGET) + ctest_build(BUILD "${CTEST_BINARY_DIRECTORY}" APPEND + RETURN_VALUE res + NUMBER_ERRORS num_errors + NUMBER_WARNINGS num_warnings) + + ctest_submit(PARTS Build) + + if(NOT dartclient_error AND res) + set(dartclient_error "Build error for SuperBuild (code ${res}): Warnings ${num_warnings}, Errors ${num_errors}") + elseif(NOT dartclient_error AND num_warnings) + set(dartclient_error "Warnings for SuperBuild: ${num_warnings}") + endif() + + # runs only tests that have a LABELS property matching "SuperBuild" + ctest_test( + BUILD "${CTEST_BINARY_DIRECTORY}" + INCLUDE_LABEL "SuperBuild" + PARALLEL_LEVEL 8 + EXCLUDE ${TEST_TO_EXCLUDE_REGEX} + RETURN_VALUE res + ) + + ctest_submit(PARTS Test) + + if(NOT dartclient_error AND res) + set(dartclient_error "Test failures for SuperBuild (code ${res})") + endif() + + set(build_dir "${CTEST_BINARY_DIRECTORY}/${PROJECT_BUILD_DIR}") + + message("----------- [ Configure ${build_dir} ] -----------") + # Configure target + ctest_configure(BUILD "${build_dir}" + OPTIONS "-DCTEST_USE_LAUNCHERS=${CTEST_USE_LAUNCHERS}" + RETURN_VALUE res + ) + ctest_read_custom_files("${CTEST_BINARY_DIRECTORY}") + ctest_submit(PARTS Configure) + + if(NOT dartclient_error AND res) + set(dartclient_error "Configure error in ${build_dir} (code ${res})") + endif() + + foreach(subproject ${CTEST_PROJECT_SUBPROJECTS}) + set_property(GLOBAL PROPERTY SubProject ${subproject}) + set_property(GLOBAL PROPERTY Label ${subproject}) + message("----------- [ Build ${subproject} ] -----------") + + # Build target + set(CTEST_BUILD_TARGET "${subproject}") + ctest_build(BUILD "${build_dir}" APPEND + RETURN_VALUE res + NUMBER_ERRORS num_errors + NUMBER_WARNINGS num_warnings) + ctest_submit(PARTS Build) + + if(NOT dartclient_error AND res) + set(dartclient_error "Build error for ${subproject} (code ${res}): Warnings ${num_warnings}, Errors ${num_errors}") + elseif(NOT dartclient_error AND num_warnings) + set(dartclient_error "Warnings for ${subproject}: ${num_warnings}") + endif() + endforeach() + + # Build the rest of the project + set_property(GLOBAL PROPERTY SubProject SuperBuild) + set_property(GLOBAL PROPERTY Label SuperBuild) + + message("----------- [ Build All ] -----------") + set(CTEST_BUILD_TARGET) + ctest_build(BUILD "${build_dir}" APPEND + RETURN_VALUE res + NUMBER_ERRORS num_errors + NUMBER_WARNINGS num_warnings) + ctest_submit(PARTS Build) + + if(NOT dartclient_error AND res) + set(dartclient_error "Build error (code ${res}): Warnings ${num_warnings}, Errors ${num_errors}") + elseif(NOT dartclient_error AND num_warnings) + set(dartclient_error "Warnings: ${num_warnings}") + endif() + + # HACK Unfortunately ctest_coverage ignores the build argument, try to force it... + file(READ ${build_dir}/CMakeFiles/TargetDirectories.txt mitk_build_coverage_dirs) + file(APPEND "${CTEST_BINARY_DIRECTORY}/CMakeFiles/TargetDirectories.txt" "${mitk_build_coverage_dirs}") + + foreach(subproject ${CTEST_PROJECT_SUBPROJECTS}) + set_property(GLOBAL PROPERTY SubProject ${subproject}) + set_property(GLOBAL PROPERTY Label ${subproject}) + message("----------- [ Test ${subproject} ] -----------") + + # runs only tests that have a LABELS property matching "${subproject}" + ctest_test( + BUILD "${build_dir}" + APPEND + INCLUDE_LABEL "${subproject}" + PARALLEL_LEVEL 8 + EXCLUDE ${TEST_TO_EXCLUDE_REGEX} + RETURN_VALUE res + ) + + ctest_submit(PARTS Test) + + if(NOT dartclient_error AND res) + set(dartclient_error "Test failures for ${subproject} (code ${res})") + endif() + + # Coverage per sub-project + if (WITH_COVERAGE AND CTEST_COVERAGE_COMMAND) + message("----------- [ Coverage ${subproject} ] -----------") + ctest_coverage(BUILD "${build_dir}" LABELS "${subproject}") + ctest_submit(PARTS Coverage) + endif () + + #if (WITH_MEMCHECK AND CTEST_MEMORYCHECK_COMMAND) + # ctest_memcheck(BUILD "${build_dir}" INCLUDE_LABEL "${subproject}") + # ctest_submit(PARTS MemCheck) + #endif () + endforeach() + + if (WITH_DOCUMENTATION) + message("----------- [ Build Documentation ] -----------") + set(CTEST_USE_LAUNCHERS 0) + # Build Documentation target + set_property(GLOBAL PROPERTY SubProject Documentation) + set_property(GLOBAL PROPERTY Label Documentation) + set(CTEST_BUILD_TARGET "doc") + ctest_build(BUILD "${build_dir}" APPEND) + ctest_submit(PARTS Build) + set(CTEST_USE_LAUNCHERS 1) + endif() + + set_property(GLOBAL PROPERTY SubProject SuperBuild) + set_property(GLOBAL PROPERTY Label SuperBuild) + + # Global coverage ... + if (WITH_COVERAGE AND CTEST_COVERAGE_COMMAND) + message("----------- [ Global coverage ] -----------") + ctest_coverage(BUILD "${build_dir}" APPEND) + ctest_submit(PARTS Coverage) + endif () + + # Global dynamic analysis ... + if (WITH_MEMCHECK AND CTEST_MEMORYCHECK_COMMAND) + message("----------- [ Global memcheck ] -----------") + ctest_memcheck(BUILD "${build_dir}") + ctest_submit(PARTS MemCheck) + endif () + + # Note should be at the end + ctest_submit(PARTS Notes) + + endif() + + # Clear the CTEST_CHECKOUT_COMMAND variable to prevent continuous clients + # to try to checkout again + set(CTEST_CHECKOUT_COMMAND "") + + if(dartclient_error) + file(WRITE ${DARTCLIENT_ERROR_FILE} "${dartclient_error}") + else() + file(REMOVE ${DARTCLIENT_ERROR_FILE}) + endif() +endmacro() + +if(SCRIPT_MODE STREQUAL "continuous") + while(1) + run_ctest() + # Loop no faster than once every 5 minutes + message("Wait for 5 minutes ...") + ctest_sleep(300) + endwhile() +else() + run_ctest() +endif() + diff --git a/CMake/MITKDashboardScript.TEMPLATE.cmake b/CMake/MITKDashboardScript.TEMPLATE.cmake new file mode 100644 index 0000000000..437d05f956 --- /dev/null +++ b/CMake/MITKDashboardScript.TEMPLATE.cmake @@ -0,0 +1,118 @@ +# +# OS: Ubuntu 9.04 2.6.28-18-generic +# Hardware: x86_64 GNU/Linux +# GPU: NA +# + +# Note: The specific version and processor type of this machine should be reported in the +# header above. Indeed, this file will be send to the dashboard as a NOTE file. + +cmake_minimum_required(VERSION 2.8.2) + +# +# Dashboard properties +# + +set(MY_COMPILER "gcc-4.4.5") +# For Windows, e.g. +#set(MY_COMPILER "VC9.0") + +set(CTEST_CMAKE_COMMAND "/usr/bin/cmake") +set(CTEST_CMAKE_GENERATOR "Unix Makefiles") +set(CTEST_DASHBOARD_ROOT "/opt/dartclients") +# For Windows, e.g. +#set(CTEST_CMAKE_COMMAND "cmake") +#set(CTEST_CMAKE_GENERATOR "Visual Studio 9 2008 Win64") +#set(CTEST_DASHBOARD_ROOT "C:/dartclients") + +# The directory containing the Qt binaries +set(QT_BINARY_DIR "/usr/bin/") +# For Windows, e.g. +#set(QT_BINARY_DIR "V:/windows/x64/QT-4.7.0_VC9.0_Bin/bin") + +# +# Dashboard options +# +set(WITH_KWSTYLE FALSE) +set(WITH_MEMCHECK FALSE) +set(WITH_COVERAGE FALSE) +set(WITH_DOCUMENTATION FALSE) +#set(DOCUMENTATION_ARCHIVES_OUTPUT_DIRECTORY ) # for example: $ENV{HOME}/Projects/Doxygen +set(CTEST_BUILD_CONFIGURATION "Release") +set(CTEST_TEST_TIMEOUT 500) +if(UNIX OR MINGW) + set(CTEST_BUILD_FLAGS "-j4") # Use multiple CPU cores to build +else() + set(CTEST_BUILD_FLAGS "") +endif() + +# experimental: +# - run_ctest() macro will be called *ONE* time +# - binary directory will *NOT* be cleaned +# continuous: +# - run_ctest() macro will be called EVERY 5 minutes ... +# - binary directory will *NOT* be cleaned +# - configure/build will be executed *ONLY* if the repository has been updated +# nightly: +# - run_ctest() macro will be called *ONE* time +# - binary directory *WILL BE* cleaned +set(SCRIPT_MODE "experimental") # "experimental", "continuous", "nightly" + +# +# Project specific properties +# +set(CTEST_SOURCE_DIRECTORY "${CTEST_DASHBOARD_ROOT}/MITK") +set(CTEST_BINARY_DIRECTORY "${CTEST_DASHBOARD_ROOT}/MITK-Superbuild-${CTEST_BUILD_CONFIGURATION}-${SCRIPT_MODE}") + +set(ADDITIONNAL_CMAKECACHE_OPTION " +MITK_USE_Boost:BOOL=ON +") + +# List of test that should be explicitly disabled on this machine +set(TEST_TO_EXCLUDE_REGEX "") + +# set any extra environment variables here +set(ENV{DISPLAY} ":0") + +find_program(CTEST_COVERAGE_COMMAND NAMES gcov) +find_program(CTEST_MEMORYCHECK_COMMAND NAMES valgrind) +find_program(CTEST_GIT_COMMAND NAMES git) + +# +# Git repository - Overwrite the default value provided by the driver script +# +# The git repository containing MITK code +#set(GIT_REPOSITORY "/home/username/MITK") +# The branch of the MITK git repository to check out +#set(GIT_BRANCH "bug-xxx-label") + +########################################## +# WARNING: DO NOT EDIT BEYOND THIS POINT # +########################################## + +# +# 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() + +# +# Download and include setup script +# +if(NOT DEFINED GIT_BRANCH OR GIT_BRANCH STREQUAL "") + set(hb "HEAD") +else() + set(hb "refs/heads/${GIT_BRANCH}") +endif() +set(url "http://mbits/gitweb/?p=MITK.git;a=blob_plain;f=CMake/MITKDashboardSetup.cmake;hb=${hb}") +set(dest ${CTEST_SCRIPT_DIRECTORY}/${CTEST_SCRIPT_NAME}.setup) +downloadFile("${url}" "${dest}") +include(${dest}) + + diff --git a/CMake/MITKDashboardSetup.cmake b/CMake/MITKDashboardSetup.cmake new file mode 100644 index 0000000000..b68de63f6f --- /dev/null +++ b/CMake/MITKDashboardSetup.cmake @@ -0,0 +1,73 @@ +# This file is intended to be included at the end of a custom MITKDashboardScript.TEMPLATE.cmake file + +list(APPEND CTEST_NOTES_FILES "${CTEST_SCRIPT_DIRECTORY}/${CTEST_SCRIPT_NAME}") + +# +# Automatically determined properties +# +set(MY_OPERATING_SYSTEM "${CMAKE_HOST_SYSTEM}") # Windows 7, Linux-2.6.32, Darwin... +site_name(CTEST_SITE) + +if(QT_BINARY_DIR) + set(QT_QMAKE_EXECUTABLE "${QT_BINARY_DIR}/qmake") +else() + set(QT_QMAKE_EXECUTABLE "qmake") +endif() + +execute_process(COMMAND ${QT_QMAKE_EXECUTABLE} --version + OUTPUT_VARIABLE MY_QT_VERSION + RESULT_VARIABLE qmake_error) +if(qmake_error) + message(FATAL_ERROR "Error when executing ${QT_QMAKE_EXECUTABLE} --version\n${qmake_error}") +endif() + +string(REGEX REPLACE ".*Qt version ([0-9.]+) .*" "\\1" MY_QT_VERSION ${MY_QT_VERSION}) + +# +# Project specific properties +# +if(NOT CTEST_BUILD_NAME) + set(CTEST_BUILD_NAME "${MY_OPERATING_SYSTEM}-${MY_COMPILER}-Qt-${MY_QT_VERSION}-${CTEST_BUILD_CONFIGURATION}") +endif() +set(PROJECT_BUILD_DIR "MITK-build") + +set(CTEST_PATH "$ENV{PATH}") +if(WIN32) + set(VTK_BINARY_DIR "${CTEST_BINARY_DIRECTORY}/VTK-build/bin/${CTEST_BUILD_CONFIGURATION}") + set(ITK_BINARY_DIR "${CTEST_BINARY_DIRECTORY}/ITK-build/bin/${CTEST_BUILD_CONFIGURATION}") + set(GDCM_BINARY_DIR "${CTEST_BINARY_DIRECTORY}/GDCM-build/bin/${CTEST_BUILD_CONFIGURATION}") + set(BLUEBERRY_OSGI_DIR "${CTEST_BINARY_DIRECTORY}/MITK-build/bin/BlueBerry/org.blueberry.osgi/bin/${CTEST_BUILD_CONFIGURATION}") + set(CTEST_PATH "${CTEST_PATH};${QT_BINARY_DIR};${VTK_BINARY_DIR};${ITK_BINARY_DIR};${GDCM_BINARY_DIR};${BLUEBERRY_OSGI_DIR}") +endif() +set(ENV{PATH} "${CTEST_PATH}") + +set(SUPERBUILD_TARGETS "") + +# If the dashscript doesn't define a GIT_REPOSITORY variable, let's define it here. +if (NOT DEFINED GIT_REPOSITORY OR GIT_REPOSITORY STREQUAL "") + set(GIT_REPOSITORY "http://mbits/git/MITK.git") +endif() + +# +# Display build info +# +message("Site name: ${CTEST_SITE}") +message("Build name: ${CTEST_BUILD_NAME}") +message("Script Mode: ${SCRIPT_MODE}") +message("Coverage: ${WITH_COVERAGE}, MemCheck: ${WITH_MEMCHECK}") + + +# +# Download and include dashboard driver script +# +if(NOT DEFINED GIT_BRANCH OR GIT_BRANCH STREQUAL "") + set(hb "HEAD") +else() + set(hb "refs/heads/${GIT_BRANCH}") +endif() +set(url "http://mbits/gitweb/?p=MITK.git;a=blob_plain;f=CMake/MITKDashboardDriverScript.cmake;hb=${hb}") +set(dest ${CTEST_SCRIPT_DIRECTORY}/${CTEST_SCRIPT_NAME}.driver) +downloadFile("${url}" "${dest}") +include(${dest}) + + diff --git a/CMake/mitkFunctionGenerateProjectXml.cmake b/CMake/mitkFunctionGenerateProjectXml.cmake new file mode 100644 index 0000000000..c0d40feaba --- /dev/null +++ b/CMake/mitkFunctionGenerateProjectXml.cmake @@ -0,0 +1,45 @@ + + +function(mitkFunctionGenerateProjectXml dir name targets is_superbuild) + if(NOT EXISTS ${dir}) + message(FATAL_ERROR "Directory ${dir} doesn't exist!") + endif() + + set(xml_subprojects ) + + if(${is_superbuild}) + set(xml_subprojects ${xml_subprojects} " \n") + endif() + + foreach(target ${targets}) + + # Remarks: Project.xml should contains all sub-project. That way + # all dashboards should submit a similar file. + + set(xml_subprojects ${xml_subprojects} " \n") + + if(${is_superbuild}) + set(xml_subprojects ${xml_subprojects} " \n") + endif() + + # Generate XML related to the dependencies + #foreach(dependency_name ${dependencies}) + # set(xml_subprojects ${xml_subprojects} " \n") + #endforeach() + + set(xml_subprojects ${xml_subprojects} " \n") + endforeach() + + set(xml_subprojects ${xml_subprojects} " \n") + foreach(subproject ${targets}) + set(xml_subprojects ${xml_subprojects} " \n") + endforeach() + set(xml_subprojects ${xml_subprojects} " \n") + + set(xml_content "\n${xml_subprojects}") + set(filename "${dir}/Project.xml") + + file(WRITE ${filename} ${xml_content}) + message(STATUS "Generated: ${filename}") +endfunction() + diff --git a/CMake/mitkMacroCreateDefaultTests.cmake b/CMake/mitkMacroCreateDefaultTests.cmake index 04113785fa..6f1df524ac 100644 --- a/CMake/mitkMacroCreateDefaultTests.cmake +++ b/CMake/mitkMacroCreateDefaultTests.cmake @@ -1,58 +1,61 @@ # Create TestDriver and default tests for MITK # # CMake variables used: # # ${${KITNAME}_GUI_TESTS} : filenames of all tests that run without a parameter # ${${KITNAME}_IMAGE_GUI_TESTS : filenames of all tests that run with an image filename as parameter # ${${KITNAME}_TESTS} : filenames of all tests that run without a parameter # ${${KITNAME}_IMAGE_TESTS : filenames of all tests that run with an image filename as parameter # ${${KITNAME}_TESTIMAGES} : list of images passed as parameter for the IMAGE_TESTS # ${${KITNAME}_CUSTOM_TESTS} : filenames of custom tests which are just added to the TestDriver. Execution # of these has to be specified manually with the ADD_TEST CMake command. # MACRO(MITK_CREATE_DEFAULT_TESTS) # add tests which need a GUI if it is not disabled IF(NOT MITK_GUI_TESTS_DISABLED) SET( ${KITNAME}_TESTS ${${KITNAME}_TESTS} ${${KITNAME}_GUI_TESTS} ) SET( ${KITNAME}_IMAGE_TESTS ${${KITNAME}_IMAGE_TESTS} ${${KITNAME}_IMAGE_GUI_TESTS} ) ENDIF(NOT MITK_GUI_TESTS_DISABLED) # # Create the TestDriver binary which contains all the tests. # CREATE_TEST_SOURCELIST(MITKTEST_SOURCE ${KITNAME}TestDriver.cpp ${${KITNAME}_TESTS} ${${KITNAME}_IMAGE_TESTS} ${${KITNAME}_CUSTOM_TESTS} ) ADD_EXECUTABLE(${KITNAME}TestDriver ${MITKTEST_SOURCE}) + set_property(TARGET ${KITNAME}TestDriver PROPERTY LABELS ${PROJECT_NAME}) TARGET_LINK_LIBRARIES(${KITNAME}TestDriver ${${KITNAME}_CORE_LIBRARIES} ${${KITNAME}_LIBRARIES} ${LIBRARIES_FOR_${KITNAME}_CORE}) # # 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 ${${KITNAME}_TESTS} ) GET_FILENAME_COMPONENT(TName ${test} NAME_WE) ADD_TEST(${TName} ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${KITNAME}TestDriver ${TName}) + set_property(TEST ${TName} PROPERTY LABELS ${PROJECT_NAME}) ENDFOREACH( test ) FOREACH(image ${${KITNAME}_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 ${CMAKE_CURRENT_SOURCE_DIR}/Data/${image}) ENDIF(EXISTS ${image}) IF(EXISTS ${IMAGE_FULL_PATH}) FOREACH( test ${${KITNAME}_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}/${KITNAME}TestDriver ${TName} ${IMAGE_FULL_PATH}) + set_property(TEST ${TName}_${ImageName} PROPERTY LABELS ${PROJECT_NAME}) ENDFOREACH( test ) ELSE(EXISTS ${IMAGE_FULL_PATH}) MESSAGE("!!!!! No such file: ${IMAGE_FULL_PATH} !!!!!") ENDIF(EXISTS ${IMAGE_FULL_PATH}) ENDFOREACH( image ) ENDMACRO(MITK_CREATE_DEFAULT_TESTS) diff --git a/CMake/mitkMacroCreateModule.cmake b/CMake/mitkMacroCreateModule.cmake index 8890743fdd..92de6363bb 100644 --- a/CMake/mitkMacroCreateModule.cmake +++ b/CMake/mitkMacroCreateModule.cmake @@ -1,151 +1,186 @@ ################################################################## # # MITK_CREATE_MODULE # # Creates a module for the automatic module dependeny system within MITK. # Configurations are generated in the moduleConf directory. # # USAGE: # # MITK_CREATE_MODULE( # [INCLUDE_DIRS ] # [INTERNAL_INCLUDE_DIRS ] # [DEPENDS ] # [PROVIDES ] # [PACKAGE_DEPENDS ] # [EXPORT_DEFINE ] # [QT_MODULE] # ################################################################## MACRO(MITK_CREATE_MODULE MODULE_NAME_IN) MACRO_PARSE_ARGUMENTS(MODULE - "INCLUDE_DIRS;INTERNAL_INCLUDE_DIRS;DEPENDS;DEPENDS_INTERNAL;PROVIDES;PACKAGE_DEPENDS;EXPORT_DEFINE;ADDITIONAL_LIBS;GENERATED_CPP" + "SUBPROJECTS;INCLUDE_DIRS;INTERNAL_INCLUDE_DIRS;DEPENDS;DEPENDS_INTERNAL;PROVIDES;PACKAGE_DEPENDS;EXPORT_DEFINE;ADDITIONAL_LIBS;GENERATED_CPP" "QT_MODULE;FORCE_STATIC;HEADERS_ONLY" ${ARGN}) SET(MODULE_NAME ${MODULE_NAME_IN}) + IF(NOT MODULE_SUBPROJECTS) + IF(MITK_DEFAULT_SUBPROJECTS) + SET(MODULE_SUBPROJECTS ${MITK_DEFAULT_SUBPROJECTS}) + ENDIF() + ENDIF() + + # check if the subprojects exist as targets + IF(MODULE_SUBPROJECTS) + FOREACH(subproject ${MODULE_SUBPROJECTS}) + IF(NOT TARGET ${subproject}) + MESSAGE(SEND_ERROR "The subproject ${subproject} does not have a corresponding target") + ENDIF() + ENDFOREACH() + ENDIF() + # assume worst case SET(MODULE_IS_ENABLED 0) # first of all we check for the dependencies MITK_CHECK_MODULE(_MISSING_DEP ${MODULE_DEPENDS}) IF(_MISSING_DEP) MESSAGE("Module ${MODULE_NAME} won't be built, missing dependency: ${_MISSING_DEP}") SET(MODULE_IS_ENABLED 0) ELSE(_MISSING_DEP) SET(MODULE_IS_ENABLED 1) # now check for every package if it is enabled. This overlaps a bit with # MITK_CHECK_MODULE ... FOREACH(_package ${MODULE_PACKAGE_DEPENDS}) IF((DEFINED MITK_USE_${_package}) AND NOT (MITK_USE_${_package})) MESSAGE("Module ${MODULE_NAME} won't be built. Turn on MITK_USE_${_package} if you want to use it.") SET(MODULE_IS_ENABLED 0) ENDIF() ENDFOREACH() IF(MODULE_IS_ENABLED) IF(NOT MODULE_QT_MODULE OR MITK_USE_QT) SET(MODULE_IS_ENABLED 1) _MITK_CREATE_MODULE_CONF() IF(NOT MODULE_EXPORT_DEFINE) SET(MODULE_EXPORT_DEFINE ${MODULE_NAME}_EXPORT) ENDIF(NOT MODULE_EXPORT_DEFINE) CONFIGURE_FILE(${MITK_SOURCE_DIR}/CMake/moduleExports.h.in ${MITK_MODULES_CONF_DIR}/${MODULE_NAME}Exports.h @ONLY) IF(MITK_GENERATE_MODULE_DOT) MESSAGE("MODULEDOTNAME ${MODULE_NAME}") FOREACH(dep ${MODULE_DEPENDS}) MESSAGE("MODULEDOT \"${MODULE_NAME}\" -> \"${dep}\" ; ") ENDFOREACH(dep) ENDIF(MITK_GENERATE_MODULE_DOT) SET(DEPENDS "${MODULE_DEPENDS}") SET(DEPENDS_BEFORE "not initialized") SET(PACKAGE_DEPENDS "${MODULE_PACKAGE_DEPENDS}") MITK_USE_MODULE("${MODULE_DEPENDS}") # ok, now create the module itself INCLUDE_DIRECTORIES(. ${ALL_INCLUDE_DIRECTORIES}) INCLUDE(files.cmake) IF(NOT MODULE_QT_MODULE) ORGANIZE_SOURCES(SOURCE ${CPP_FILES} HEADER ${H_FILES} TXX ${TXX_FILES} DOC ${DOX_FILES} ) IF(MODULE_FORCE_STATIC) SET(_STATIC ${MITK_WIN32_FORCE_STATIC}) ENDIF(MODULE_FORCE_STATIC) + + SET(coverage_sources ${CPP_FILES} ${H_FILES} ${GLOBBED__H_FILES} ${CORRESPONDING__H_FILES} ${TXX_FILES} ${TOOL_CPPS}) + IF(MODULE_SUBPROJECTS) + SET_PROPERTY(SOURCE ${coverage_sources} APPEND PROPERTY LABELS ${MODULE_SUBPROJECTS} MITK) + ENDIF() IF(NOT MODULE_HEADERS_ONLY) IF(ALL_LIBRARY_DIRS) # LINK_DIRECTORIES applies only to targets which are added after the call to LINK_DIRECTORIES LINK_DIRECTORIES(${ALL_LIBRARY_DIRS}) - ENDIF(ALL_LIBRARY_DIRS) - ADD_LIBRARY(${MODULE_PROVIDES} ${_STATIC} ${CPP_FILES} ${H_FILES} ${CPP_FILES_GENERATED} ${GLOBBED__H_FILES} ${CORRESPONDING__H_FILES} ${TXX_FILES} ${DOX_FILES} ${UI_FILES} ${TOOL_CPPS}) + ENDIF(ALL_LIBRARY_DIRS) + ADD_LIBRARY(${MODULE_PROVIDES} ${_STATIC} ${coverage_sources} ${CPP_FILES_GENERATED} ${DOX_FILES} ${UI_FILES}) + IF(MODULE_SUBPROJECTS) + SET_PROPERTY(TARGET ${MODULE_PROVIDES} PROPERTY LABELS ${MODULE_SUBPROJECTS} MITK) + FOREACH(subproject ${MODULE_SUBPROJECTS}) + ADD_DEPENDENCIES(${subproject} ${MODULE_PROVIDES}) + ENDFOREACH() + ENDIF() IF(ALL_LIBRARIES) TARGET_LINK_LIBRARIES(${MODULE_PROVIDES} ${ALL_LIBRARIES}) ENDIF(ALL_LIBRARIES) ENDIF() ELSE(NOT MODULE_QT_MODULE) INCLUDE(files.cmake) IF(UI_FILES) QT4_WRAP_UI(Q${KITNAME}_GENERATED_UI_CPP ${UI_FILES}) ENDIF(UI_FILES) IF(MOC_H_FILES) QT4_WRAP_CPP(Q${KITNAME}_GENERATED_MOC_CPP ${MOC_H_FILES}) ENDIF(MOC_H_FILES) IF(QRC_FILES) QT4_ADD_RESOURCES(Q${KITNAME}_GENERATED_QRC_CPP ${QRC_FILES}) ENDIF(QRC_FILES) SET(Q${KITNAME}_GENERATED_CPP ${Q${KITNAME}_GENERATED_CPP} ${Q${KITNAME}_GENERATED_UI_CPP} ${Q${KITNAME}_GENERATED_MOC_CPP} ${Q${KITNAME}_GENERATED_QRC_CPP}) ORGANIZE_SOURCES(SOURCE ${CPP_FILES} HEADER ${H_FILES} TXX ${TXX_FILES} DOC ${DOX_FILES} UI ${UI_FILES} QRC ${QRC_FILES} MOC ${Q${KITNAME}_GENERATED_MOC_CPP} GEN_QRC ${Q${KITNAME}_GENERATED_QRC_CPP} GEN_UI ${Q${KITNAME}_GENERATED_UI_CPP}) # MITK_GENERATE_TOOLS_LIBRARY(Qmitk${LIBPOSTFIX} "NO") + + SET(coverage_sources ${CPP_FILES} ${CORRESPONDING__H_FILES} ${GLOBBED__H_FILES} ${TXX_FILES} ${TOOL_GUI_CPPS}) + SET_PROPERTY(SOURCE ${coverage_sources} APPEND PROPERTY LABELS ${MODULE_SUBPROJECTS}) IF(NOT MODULE_HEADERS_ONLY) IF(ALL_LIBRARY_DIRS) # LINK_DIRECTORIES applies only to targets which are added after the call to LINK_DIRECTORIES LINK_DIRECTORIES(${ALL_LIBRARY_DIRS}) - ENDIF(ALL_LIBRARY_DIRS) - ADD_LIBRARY(${MODULE_PROVIDES} ${CPP_FILES} ${CPP_FILES_GENERATED} ${Q${KITNAME}_GENERATED_CPP} ${CORRESPONDING__H_FILES} ${GLOBBED__H_FILES} ${TXX_FILES} ${DOX_FILES} ${UI_FILES} ${QRC_FILES} ${TOOL_GUI_CPPS}) + ENDIF(ALL_LIBRARY_DIRS) + ADD_LIBRARY(${MODULE_PROVIDES} ${coverage_sources} ${CPP_FILES_GENERATED} ${Q${KITNAME}_GENERATED_CPP} ${DOX_FILES} ${UI_FILES} ${QRC_FILES}) TARGET_LINK_LIBRARIES(${MODULE_PROVIDES} ${QT_LIBRARIES} ${ALL_LIBRARIES} QVTK) + IF(MODULE_SUBPROJECTS) + SET_PROPERTY(TARGET ${MODULE_PROVIDES} PROPERTY LABELS ${MODULE_SUBPROJECTS} MITK) + FOREACH(subproject ${MODULE_SUBPROJECTS}) + ADD_DEPENDENCIES(${subproject} ${MODULE_PROVIDES}) + ENDFOREACH() + ENDIF() ENDIF() ENDIF(NOT MODULE_QT_MODULE) IF(NOT MODULE_HEADERS_ONLY AND TARGET EP_MITK) ADD_DEPENDENCIES(${MODULE_PROVIDES} EP_MITK) ENDIF() # install only if shared lib (for now) IF(NOT _STATIC OR MINGW) IF(NOT MODULE_HEADERS_ONLY) # # deprecated: MITK_INSTALL_TARGETS(${MODULE_PROVIDES}) ENDIF() ENDIF(NOT _STATIC OR MINGW) ENDIF(NOT MODULE_QT_MODULE OR MITK_USE_QT) ENDIF(MODULE_IS_ENABLED) ENDIF(_MISSING_DEP) IF(NOT MODULE_IS_ENABLED) _MITK_CREATE_MODULE_CONF() ENDIF(NOT MODULE_IS_ENABLED) ENDMACRO(MITK_CREATE_MODULE) diff --git a/CMake/mitkMacroCreateModuleTests.cmake b/CMake/mitkMacroCreateModuleTests.cmake index 978c3d04de..4f2eb1e30a 100644 --- a/CMake/mitkMacroCreateModuleTests.cmake +++ b/CMake/mitkMacroCreateModuleTests.cmake @@ -1,71 +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}) 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}) - ENDFOREACH( test ) + 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) + 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/CMake/mitkMacroCreatePlugin.cmake b/CMake/mitkMacroCreatePlugin.cmake index 914541684f..f7f7984532 100755 --- a/CMake/mitkMacroCreatePlugin.cmake +++ b/CMake/mitkMacroCreatePlugin.cmake @@ -1,19 +1,25 @@ MACRO(MACRO_CREATE_MITK_PLUGIN) MITK_CHECK_MODULE(_MODULE_CHECK_RESULT Mitk ${ARGN}) IF(NOT _MODULE_CHECK_RESULT) - MITK_USE_MODULE(Mitk ${ARGN}) - - LINK_DIRECTORIES(${ALL_LIBRARY_DIRS}) - INCLUDE_DIRECTORIES(${ALL_INCLUDE_DIRECTORIES}) - MACRO_CREATE_PLUGIN() + MITK_USE_MODULE(Mitk ${ARGN}) + + LINK_DIRECTORIES(${ALL_LIBRARY_DIRS}) + INCLUDE_DIRECTORIES(${ALL_INCLUDE_DIRECTORIES}) + MACRO_CREATE_PLUGIN() - TARGET_LINK_LIBRARIES(${PLUGIN_TARGET} ${ALL_LIBRARIES}) + TARGET_LINK_LIBRARIES(${PLUGIN_TARGET} ${ALL_LIBRARIES}) + IF(MITK_DEFAULT_SUBPROJECTS) + SET_PROPERTY(TARGET ${PLUGIN_TARGET} PROPERTY LABELS ${MITK_DEFAULT_SUBPROJECTS}) + FOREACH(subproject ${MITK_DEFAULT_SUBPROJECTS}) + ADD_DEPENDENCIES(${subproject} ${PLUGIN_TARGET}) + ENDFOREACH() + ENDIF() ELSE(NOT _MODULE_CHECK_RESULT) IF(NOT MITK_BUILD_ALL_PLUGINS) MESSAGE(SEND_ERROR "${BUNDLE-SYMBOLICNAME} is missing requirements and won't be built. Missing: ${_MODULE_CHECK_RESULT}") ELSE() MESSAGE(STATUS "${BUNDLE-SYMBOLICNAME} is missing requirements and won't be built. Missing: ${_MODULE_CHECK_RESULT}") ENDIF() ENDIF(NOT _MODULE_CHECK_RESULT) ENDMACRO() diff --git a/CMakeLists.txt b/CMakeLists.txt index ac7923eb11..177bcf9fb7 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,410 +1,450 @@ cmake_minimum_required(VERSION 2.8.2) #----------------------------------------------------------------------------- # Superbuild Option - Enabled by default #----------------------------------------------------------------------------- option(MITK_USE_SUPERBUILD "Build MITK and the projects it depends on via SuperBuild.cmake." ON) if(MITK_USE_SUPERBUILD) project(MITK-superbuild) set(MITK_SOURCE_DIR ${PROJECT_SOURCE_DIR}) set(MITK_BINARY_DIR ${PROJECT_BINARY_DIR}) else() project(MITK) endif() #----------------------------------------------------------------------------- # 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) +include(mitkFunctionGenerateProjectXml) #----------------------------------------------------------------------------- # 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) +#----------------------------------------------------------------------------- +# Project.xml +#----------------------------------------------------------------------------- + +# A list of topologically ordered targets +set(CTEST_PROJECT_SUBPROJECTS) +if(MITK_USE_BLUEBERRY) + list(APPEND CTEST_PROJECT_SUBPROJECTS BlueBerry) +endif() + +list(APPEND CTEST_PROJECT_SUBPROJECTS + MITK-Core + MITK-CoreUI + MITK-IGT + MITK-DTI + MITK-Registration + MITK-Modules # all modules not contained in a specific subproject + MITK-Plugins # all plugins not contained in a specific subproject + ) + +# Configure CTestConfigSubProject.cmake that could be used by CTest scripts +configure_file(${MITK_SOURCE_DIR}/CTestConfigSubProject.cmake.in + ${MITK_BINARY_DIR}/CTestConfigSubProject.cmake) + +# Generate Project.xml file expected by the CTest driver script +mitkFunctionGenerateProjectXml(${MITK_BINARY_DIR} ${PROJECT_NAME} "${CTEST_PROJECT_SUBPROJECTS}" ${MITK_USE_SUPERBUILD}) + #----------------------------------------------------------------------------- # 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) + + option(MITK_ENABLE_GUI_TESTING OFF "Enable the MITK GUI tests") # 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 ") 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 custom targets representing CDash subprojects +#----------------------------------------------------------------------------- + +foreach(subproject ${CTEST_PROJECT_SUBPROJECTS}) + if(NOT TARGET ${subproject}) + add_custom_target(${subproject}) + endif() +endforeach() + #----------------------------------------------------------------------------- # 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/CTestConfig.cmake b/CTestConfig.cmake new file mode 100644 index 0000000000..9643bb76ad --- /dev/null +++ b/CTestConfig.cmake @@ -0,0 +1,8 @@ +set(CTEST_PROJECT_NAME "MITK") +set(CTEST_NIGHTLY_START_TIME "23:00:00 EDT") + +set(CTEST_DROP_METHOD "http") +set(CTEST_DROP_SITE "cdash.mitk.org") +set(CTEST_DROP_LOCATION "/submit.php?project=MITK") +set(CTEST_DROP_SITE_CDASH TRUE) + diff --git a/CTestConfigSubProject.cmake.in b/CTestConfigSubProject.cmake.in new file mode 100644 index 0000000000..5bff13cd9b --- /dev/null +++ b/CTestConfigSubProject.cmake.in @@ -0,0 +1,2 @@ +set(CTEST_PROJECT_SUBPROJECTS @CTEST_PROJECT_SUBPROJECTS@) + diff --git a/Core/CMakeLists.txt b/Core/CMakeLists.txt index c5632ab443..3ba203af54 100644 --- a/Core/CMakeLists.txt +++ b/Core/CMakeLists.txt @@ -1,2 +1,4 @@ +SET(MITK_DEFAULT_SUBPROJECTS MITK-Core) + ADD_SUBDIRECTORY(Code) diff --git a/Core/Code/Testing/CMakeLists.txt b/Core/Code/Testing/CMakeLists.txt index 0a3496a186..8ad3992bf4 100644 --- a/Core/Code/Testing/CMakeLists.txt +++ b/Core/Code/Testing/CMakeLists.txt @@ -1,7 +1,8 @@ -MITK_CREATE_MODULE_TESTS() +MITK_CREATE_MODULE_TESTS(LABELS MITK-Core) # MITK_INSTALL_TARGETS(EXECUTABLES MitkTestDriver) ADD_TEST(mitkPicFileReaderTest_emptyFile ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${TESTDRIVER} mitkPicFileReaderTest ${CMAKE_CURRENT_SOURCE_DIR}/Data/emptyFile.pic) +SET_PROPERTY(TEST mitkPicFileReaderTest_emptyFile PROPERTY LABELS MITK-Core) ADD_TEST(mitkPicFileReaderTest_emptyGzipFile ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${TESTDRIVER} mitkPicFileReaderTest ${CMAKE_CURRENT_SOURCE_DIR}/Data/emptyFile.pic.gz) - +SET_PROPERTY(TEST mitkPicFileReaderTest_emptyGzipFile PROPERTY LABELS MITK-Core) diff --git a/CoreUI/BundleTesting/CMakeLists.txt b/CoreUI/BundleTesting/CMakeLists.txt index d7763917a6..583e57c265 100644 --- a/CoreUI/BundleTesting/CMakeLists.txt +++ b/CoreUI/BundleTesting/CMakeLists.txt @@ -1,28 +1,25 @@ IF(MITK_USE_BLUEBERRY) - SET(MITK_USE_BLUEBERRY 1) - FIND_PACKAGE(MITK REQUIRED) IF(NOT BLUEBERRY_MFPARSER) INCLUDE(${MITK_BINARY_DIR}/Bundles/MITKCoreBundleList.cmake) ENDIF() INCLUDE(berryTestingHelpers) SET(BLUEBERRY_TEST_APP "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/CoreApp") GET_TARGET_PROPERTY(_is_macosx_bundle CoreApp MACOSX_BUNDLE) IF(APPLE AND _is_macosx_bundle) SET(BLUEBERRY_TEST_APP "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/CoreApp.app/Contents/MacOS/CoreApp") ENDIF() SET(BLUEBERRY_TEST_APP_ID "org.mitk.qt.application") MACRO_COLLECT_PLUGINS(OUTPUT_DIR ${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/CoreBundles CACHE_PLUGIN_SOURCE_DIRS MITK_CORE_PLUGIN_SOURCE_DIRS CACHE_PLUGIN_OUTPUT_DIRS MITK_CORE_PLUGIN_OUTPUT_DIRS CACHE_PLUGIN_TARGETS MITK_CORE_ENABLED_TEST_PLUGINS CMAKE_CACHE_PREFIX "MITK" # DEPENDS "${BLUEBERRY_PLUGINS_OUTPUT_DIR}" "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/CoreBundles" ${MITK_BUILD_ALL_PLUGINS_OPTION}) -MESSAGE("SUFFIX: ${CMAKE_EXECUTABLE_SUFFIX}") ENDIF(MITK_USE_BLUEBERRY) diff --git a/CoreUI/BundleTesting/org.mitk.gui.qt.common.tests/CMakeLists.txt b/CoreUI/BundleTesting/org.mitk.gui.qt.common.tests/CMakeLists.txt index 8bf5b641df..9be81e7896 100644 --- a/CoreUI/BundleTesting/org.mitk.gui.qt.common.tests/CMakeLists.txt +++ b/CoreUI/BundleTesting/org.mitk.gui.qt.common.tests/CMakeLists.txt @@ -1,3 +1,4 @@ MACRO_CREATE_MITK_PLUGIN(Qmitk) -MACRO_TEST_UIPLUGIN() \ No newline at end of file +MACRO_TEST_UIPLUGIN(${MITK_DEFAULT_SUBPROJECTS}) + diff --git a/CoreUI/CMakeLists.txt b/CoreUI/CMakeLists.txt index 900a743190..944f180b67 100644 --- a/CoreUI/CMakeLists.txt +++ b/CoreUI/CMakeLists.txt @@ -1,15 +1,14 @@ +SET(MITK_DEFAULT_SUBPROJECTS MITK-CoreUI) + IF(MITK_USE_QT AND QT4_FOUND) ADD_SUBDIRECTORY(Qmitk) ENDIF() IF(MITK_USE_BLUEBERRY) ADD_SUBDIRECTORY(Bundles) - IF(BLUEBERRY_ENABLE_GUI_TESTING) - SET (MITK_ENABLE_GUI_TESTING OFF CACHE BOOL "Enables BlueBerry based GUI Tests for MITK Bundles") - IF(MITK_ENABLE_GUI_TESTING) - # ADD_SUBDIRECTORY(BundleTesting) - ENDIF(MITK_ENABLE_GUI_TESTING) - ENDIF(BLUEBERRY_ENABLE_GUI_TESTING) + IF(MITK_ENABLE_GUI_TESTING AND BLUEBERRY_ENABLE_GUI_TESTING) + ADD_SUBDIRECTORY(BundleTesting) + ENDIF() ENDIF() diff --git a/DartConfig.cmake b/DartConfig.cmake deleted file mode 100644 index 25414b1c86..0000000000 --- a/DartConfig.cmake +++ /dev/null @@ -1,75 +0,0 @@ -OPTION(USE_MITK_ORG_DASHBOARD "Use the dartboard on mitk.org for build submissions." OFF) - -# internal cdash -set(CTEST_PROJECT_NAME "MITK") -set(CTEST_NIGHTLY_START_TIME "21:00:00 CEST") -set(NIGHTLY_START_TIME "21:00:00 CEST") - -set(CTEST_DROP_METHOD "http") -set(CTEST_DROP_SITE "mbits") -set(CTEST_DROP_LOCATION "/cdash/submit.php?project=MITK") -set(CTEST_DROP_SITE_CDASH TRUE) -set(DROP_METHOD "http") -set(DROP_SITE "mbits") -set(DROP_LOCATION "/cdash/submit.php?project=MITK") - - -# configure dart for submission to kitware -IF(USE_MITK_ORG_DASHBOARD) -# -# Dart server to submit results (used by client) -# - SET(DROP_METHOD "http") - SET(DROP_SITE "cdash.mitk.org") - SET(DROP_LOCATION "/submit.php?project=MITK") - SET(CTEST_DROP_METHOD "http") - SET(CTEST_DROP_SITE "cdash.mitk.org") - SET(CTEST_DROP_LOCATION "/submit.php?project=MITK") - SET(CTEST_DROP_SITE_CDASH TRUE) - - SET(CTEST_NIGHTLY_START_TIME "21:00 CEST") - SET (NIGHTLY_START_TIME "21:00:00 CEST") - - SET (DOXYGEN_URL "http://docs.mitk.org/nightly-qt4/" ) - -ENDIF(USE_MITK_ORG_DASHBOARD) - -IF(EXISTS ${MBI_DART_WORKDIR}/notes.txt) - MAKE_DIRECTORY(${MBI_DART_WORKDIR}/bin/Testing/Notes) - CONFIGURE_FILE(${MBI_DART_WORKDIR}/notes.txt ${MBI_DART_WORKDIR}/bin/Testing/Notes/notes.txt COPYONLY) -ENDIF(EXISTS ${MBI_DART_WORKDIR}/notes.txt) -IF(EXISTS ${ITK_DIR}/ITKConfig.cmake) - INCLUDE(${ITK_DIR}/ITKConfig.cmake) -ENDIF(EXISTS ${ITK_DIR}/ITKConfig.cmake) - -IF(EXISTS ${VTK_DIR}/VTKConfig.cmake) - # this second check is necessary since sometimes on the very first - # CMake run VTKConfig exists but VTKConfigQt doesn't exist yet, breaking the - # configure step - IF(EXISTS ${VTK_DIR}/VTKConfigQt.cmake) - INCLUDE(${VTK_DIR}/VTKConfig.cmake) - ENDIF(EXISTS ${VTK_DIR}/VTKConfigQt.cmake) -ENDIF(EXISTS ${VTK_DIR}/VTKConfig.cmake) - -IF(CMAKE_COMPILER_IS_GNUCXX) - MESSAGE(STATUS "Compiler is GCC") - EXEC_PROGRAM(${CMAKE_CXX_COMPILER} - ARGS --version - OUTPUT_VARIABLE COMPILER_OUTPUT - ) -ENDIF(CMAKE_COMPILER_IS_GNUCXX) -MESSAGE(STATUS "Compiler version output: ${COMPILER_OUTPUT}") - -SET(BUILD_NOTES_DIR ${PROJECT_BINARY_DIR}/Testing/Notes) -MAKE_DIRECTORY(${BUILD_NOTES_DIR}) -SET(BUILD_NOTES_FILE ${BUILD_NOTES_DIR}/build-notes.txt) -FILE(WRITE ${BUILD_NOTES_FILE} "Toolkit versions for this build: -ITK_DIR: ${ITK_DIR} -VTK_DIR: ${VTK_DIR} -VTK version: ${VTK_MAJOR_VERSION}.${VTK_MINOR_VERSION}.${VTK_BUILD_VERSION} -ITK version: ${ITK_VERSION_MAJOR}.${ITK_VERSION_MINOR}.${ITK_VERSION_PATCH} -COMPILER output string: ${COMPILER_OUTPUT} -") - -# if we are part of a larger project, they maybe use other Dart configuration -INCLUDE(../DartConfig.cmake OPTIONAL) diff --git a/Modules/Bundles/CMakeLists.txt b/Modules/Bundles/CMakeLists.txt index bf6a99cc78..0ad7262b5d 100644 --- a/Modules/Bundles/CMakeLists.txt +++ b/Modules/Bundles/CMakeLists.txt @@ -1,34 +1,36 @@ IF(MITK_USE_BLUEBERRY) # INCLUDE("${MITK_BINARY_DIR}/mitkExtConfig.cmake") # INCLUDE("${MITK_BINARY_DIR}/QmitkExtConfig.cmake") INCLUDE("${MITK_BINARY_DIR}/Bundles/MITKCoreBundleList.cmake") + SET(MITK_DEFAULT_SUBPROJECTS MITK-Plugins) + SET(_mitk_bundles_default "org.mitk.core.ext" "org.mitk.planarfigure" ) IF(QT4_FOUND) LIST(APPEND _mitk_bundles_default "org.mitk.gui.qt.ext" "org.mitk.gui.qt.extapplication") # ExtApp required bundles LIST(APPEND _mitk_bundles_default "org.mitk.gui.qt.imagenavigator" "org.mitk.gui.qt.datamanager") ENDIF() SET(PLUGIN_EXCLUDE_LIST org.mitk.gui.qt.volumetry ) MACRO_COLLECT_PLUGINS(OUTPUT_DIR ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/ExtBundles CACHE_PLUGIN_SOURCE_DIRS MITK_MODULES_PLUGIN_SOURCE_DIRS CACHE_PLUGIN_OUTPUT_DIRS MITK_MODULES_PLUGIN_OUTPUT_DIRS CACHE_PLUGIN_TARGETS MITK_MODULES_ENABLED_PLUGINS BUNDLE_LIST_PATH "${MITK_BINARY_DIR}/Bundles/MITKModulesBundleList.cmake" CMAKE_CACHE_PREFIX "MITK" PLUGIN_DEFAULT_ON ${_mitk_bundles_default} PLUGIN_EXCLUDES ${PLUGIN_EXCLUDE_LIST} ${MITK_BUILD_ALL_PLUGINS_OPTION}) ENDIF(MITK_USE_BLUEBERRY) diff --git a/Modules/CMakeLists.txt b/Modules/CMakeLists.txt index cbb5ea1f93..316a06f6cf 100644 --- a/Modules/CMakeLists.txt +++ b/Modules/CMakeLists.txt @@ -1,21 +1,30 @@ SET(LIBPOSTFIX "Ext") -ADD_SUBDIRECTORY(SceneSerializationBase) -ADD_SUBDIRECTORY(PlanarFigure) -ADD_SUBDIRECTORY(MitkExt) -ADD_SUBDIRECTORY(SceneSerialization) -ADD_SUBDIRECTORY(QmitkExt) -ADD_SUBDIRECTORY(DiffusionImaging) -ADD_SUBDIRECTORY(GPGPU) -ADD_SUBDIRECTORY(IGT) -ADD_SUBDIRECTORY(IGTUI) -ADD_SUBDIRECTORY(RigidRegistration) -ADD_SUBDIRECTORY(RigidRegistrationUI) -ADD_SUBDIRECTORY(DeformableRegistration) -ADD_SUBDIRECTORY(DeformableRegistrationUI) -ADD_SUBDIRECTORY(OpenCVVideoSupport) -ADD_SUBDIRECTORY(Overlays) -ADD_SUBDIRECTORY(InputDevices) + +SET(module_dirs + SceneSerializationBase + PlanarFigure + MitkExt + SceneSerialization + QmitkExt + DiffusionImaging + GPGPU + IGT + IGTUI + RigidRegistration + RigidRegistrationUI + DeformableRegistration + DeformableRegistrationUI + OpenCVVideoSupport + Overlays + InputDevices +) + +SET(MITK_DEFAULT_SUBPROJECTS MITK-Modules) + +FOREACH(module_dir ${module_dirs}) + ADD_SUBDIRECTORY(${module_dir}) +ENDFOREACH() IF(MITK_USE_BLUEBERRY) ADD_SUBDIRECTORY(Bundles) ENDIF() diff --git a/Modules/DeformableRegistration/CMakeLists.txt b/Modules/DeformableRegistration/CMakeLists.txt index 0f3b664ecd..3bba8ee0c0 100644 --- a/Modules/DeformableRegistration/CMakeLists.txt +++ b/Modules/DeformableRegistration/CMakeLists.txt @@ -1,7 +1,8 @@ MITK_CREATE_MODULE(MitkDeformableRegistration + SUBPROJECTS MITK-Registration DEPENDS Mitk MitkRigidRegistration PROVIDES MitkDeformableRegistration EXPORT_DEFINE MITK_DEFORMABLEREGISTRATION_EXPORT ) ADD_SUBDIRECTORY(Testing) diff --git a/Modules/DeformableRegistrationUI/CMakeLists.txt b/Modules/DeformableRegistrationUI/CMakeLists.txt index be87e9c5ca..f586ab68d0 100644 --- a/Modules/DeformableRegistrationUI/CMakeLists.txt +++ b/Modules/DeformableRegistrationUI/CMakeLists.txt @@ -1,6 +1,7 @@ MITK_CREATE_MODULE(MitkDeformableRegistrationUI + SUBPROJECTS MITK-Registration DEPENDS Qmitk MitkDeformableRegistration QT_MODULE PROVIDES MitkDeformableRegistrationUI EXPORT_DEFINE MITK_DEFORMABLEREGISTRATION_UI_EXPORT ) diff --git a/Modules/DiffusionImaging/CMakeLists.txt b/Modules/DiffusionImaging/CMakeLists.txt index 2910eacd25..3eda59963a 100644 --- a/Modules/DiffusionImaging/CMakeLists.txt +++ b/Modules/DiffusionImaging/CMakeLists.txt @@ -1,19 +1,20 @@ FIND_PACKAGE(ITK) IF(ITK_GDCM_DIR) INCLUDE(${ITK_GDCM_DIR}/GDCMConfig.cmake) IF(GDCM_MAJOR_VERSION EQUAL 2) ADD_DEFINITIONS(-DGDCM2) SET(ITK_USES_GDCM2 1) ENDIF(GDCM_MAJOR_VERSION EQUAL 2) ENDIF(ITK_GDCM_DIR) MITK_CREATE_MODULE( MitkDiffusionImaging + SUBPROJECTS MITK-DTI INCLUDE_DIRS Algorithms DicomImport IODataStructures/DiffusionWeightedImages IODataStructures/QBallImages IODataStructures/TensorImages IODataStructures Reconstruction Tractography Rendering ${CMAKE_CURRENT_BINARY_DIR} DEPENDS MitkExt PACKAGE_DEPENDS Boost ) ADD_SUBDIRECTORY(Testing) CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/mitkDiffusionImagingConfigure.h.in ${CMAKE_CURRENT_BINARY_DIR}/mitkDiffusionImagingConfigure.h) diff --git a/Modules/IGT/CMakeLists.txt b/Modules/IGT/CMakeLists.txt index 5aa0b6fbc1..86c067a85e 100644 --- a/Modules/IGT/CMakeLists.txt +++ b/Modules/IGT/CMakeLists.txt @@ -1,29 +1,30 @@ INCLUDE(MITKIGTHardware.cmake) IF(MITK_USE_MICRON_TRACKER) SET(INCLUDE_DIRS_INTERNAL ${INCLUDE_DIRS_INTERNAL} ${MITK_MICRON_TRACKER_INCLUDE_DIR}) SET(ADDITIONAL_LIBS ${ADDITIONAL_LIBS} ${MITK_MICRON_TRACKER_LIB}) ENDIF(MITK_USE_MICRON_TRACKER) IF(MITK_USE_MICROBIRD_TRACKER) SET(INCLUDE_DIRS_INTERNAL ${INCLUDE_DIRS_INTERNAL} ${MITK_USE_MICROBIRD_TRACKER_INCLUDE_DIR}) SET(ADDITIONAL_LIBS ${ADDITIONAL_LIBS} ${MITK_USE_MICROBIRD_TRACKER_LIB}) ENDIF(MITK_USE_MICROBIRD_TRACKER) MITK_CREATE_MODULE(MitkIGT + SUBPROJECTS MITK-IGT INCLUDE_DIRS IGTFilters IGTTrackingDevices IGTToolManagement INTERNAL_INCLUDE_DIRS ${INCLUDE_DIRS_INTERNAL} DEPENDS Mitk tinyxml SceneSerialization PROVIDES mitkIGT ADDITIONAL_LIBS "${ADDITIONAL_LIBS}" ) ## create IGT config CONFIGURE_FILE(mitkIGTConfig.h.in ${PROJECT_BINARY_DIR}/mitkIGTConfig.h @ONLY) # add test programm for serial communication classADD_EXECUTABLE(SerialCommunicationTest IGTTrackingDevices/mitkSerialCommunicationTest.cpp)TARGET_LINK_LIBRARIES(SerialCommunicationTest mitkIGT mitkCore tinyxml PocoXML) ADD_EXECUTABLE (IGTTutorialStep1 IGTTutorial/IGTTutorialStep1.cpp) TARGET_LINK_LIBRARIES(IGTTutorialStep1 mitkIGT mitkCore tinyxml PocoXML) ADD_SUBDIRECTORY(Testing) diff --git a/Modules/IGTUI/CMakeLists.txt b/Modules/IGTUI/CMakeLists.txt index 5bc10ae910..a748a81d18 100644 --- a/Modules/IGTUI/CMakeLists.txt +++ b/Modules/IGTUI/CMakeLists.txt @@ -1,12 +1,13 @@ MITK_CREATE_MODULE(MitkIGTUI + SUBPROJECTS MITK-IGT INCLUDE_DIRS Qmitk DEPENDS MitkIGT Qmitk QmitkExt PROVIDES mitkIGTUI QT_MODULE GENERATED_CPP ${TOOL_GUI_CPPS} ${TOOL_CPPS} ) ## create IGTUI config CONFIGURE_FILE(mitkIGTUIConfig.h.in ${PROJECT_BINARY_DIR}/mitkIGTUIConfig.h @ONLY) diff --git a/Modules/PlanarFigure/Interactions/mitkPlanarFigureInteractor.cpp b/Modules/PlanarFigure/Interactions/mitkPlanarFigureInteractor.cpp index 8a0c1bb965..264761fe1f 100644 --- a/Modules/PlanarFigure/Interactions/mitkPlanarFigureInteractor.cpp +++ b/Modules/PlanarFigure/Interactions/mitkPlanarFigureInteractor.cpp @@ -1,756 +1,768 @@ /*========================================================================= Program: Medical Imaging & Interaction Toolkit Language: C++ Date: $Date: 2008-10-02 16:21:08 +0200 (Do, 02 Okt 2008) $ Version: $Revision: 13129 $ Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. See MITKCopyright.txt or http://www.mitk.org/copyright.html for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "mitkPlanarFigureInteractor.h" #include "mitkPointOperation.h" #include "mitkPositionEvent.h" #include "mitkPlanarFigure.h" #include "mitkStatusBar.h" #include "mitkDataNode.h" #include "mitkInteractionConst.h" #include "mitkAction.h" #include "mitkStateEvent.h" #include "mitkOperationEvent.h" #include "mitkUndoController.h" #include "mitkStateMachineFactory.h" #include "mitkStateTransitionOperation.h" #include "mitkBaseRenderer.h" #include "mitkRenderingManager.h" #include "mitkNodePredicateDataType.h" #include "mitkNodePredicateOr.h" //how precise must the user pick the point //default value mitk::PlanarFigureInteractor ::PlanarFigureInteractor(const char * type, DataNode* dataNode, int /* n */ ) : Interactor( type, dataNode ), m_Precision( 6.5 ), m_IsHovering( false ) { } mitk::PlanarFigureInteractor::~PlanarFigureInteractor() { } void mitk::PlanarFigureInteractor::SetPrecision( mitk::ScalarType precision ) { m_Precision = precision; } // Overwritten since this class can handle it better! float mitk::PlanarFigureInteractor ::CanHandleEvent(StateEvent const* stateEvent) const { float returnValue = 0.5; // If it is a key event that can be handled in the current state, // then return 0.5 mitk::DisplayPositionEvent const *disPosEvent = dynamic_cast (stateEvent->GetEvent()); // Key event handling: if (disPosEvent == NULL) { // Check if the current state has a transition waiting for that key event. if (this->GetCurrentState()->GetTransition(stateEvent->GetId())!=NULL) { return 0.5; } else { return 0.0; } } mitk::PlanarFigure *planarFigure = dynamic_cast( m_DataNode->GetData() ); if ( planarFigure != NULL ) { // Give higher priority if this figure is currently selected if ( planarFigure->GetSelectedControlPoint() >= 0 ) { return 1.0; } } return returnValue; } bool mitk::PlanarFigureInteractor ::ExecuteAction( Action *action, mitk::StateEvent const *stateEvent ) { bool ok = false; // Check corresponding data; has to be sub-class of mitk::PlanarFigure mitk::PlanarFigure *planarFigure = dynamic_cast< mitk::PlanarFigure * >( m_DataNode->GetData() ); if ( planarFigure == NULL ) { return false; } // Get the timestep to also support 3D+t const mitk::Event *theEvent = stateEvent->GetEvent(); int timeStep = 0; mitk::ScalarType timeInMS = 0.0; if ( theEvent ) { if (theEvent->GetSender() != NULL) { timeStep = theEvent->GetSender()->GetTimeStep( planarFigure ); timeInMS = theEvent->GetSender()->GetTime(); } } // Get Geometry2D of PlanarFigure mitk::Geometry2D *planarFigureGeometry = dynamic_cast< mitk::Geometry2D * >( planarFigure->GetGeometry( timeStep ) ); // Get the Geometry2D of the window the user interacts with (for 2D point // projection) mitk::BaseRenderer *renderer = NULL; const Geometry2D *projectionPlane = NULL; if ( theEvent ) { renderer = theEvent->GetSender(); projectionPlane = renderer->GetCurrentWorldGeometry2D(); } // TODO: Check if display and PlanarFigure geometries are parallel (if they are PlaneGeometries) switch (action->GetActionId()) { case AcDONOTHING: ok = true; break; case AcCHECKOBJECT: { if ( planarFigure->IsPlaced() ) { this->HandleEvent( new mitk::StateEvent( EIDYES, NULL ) ); } else { this->HandleEvent( new mitk::StateEvent( EIDNO, NULL ) ); } ok = false; break; } case AcADD: { // Invoke event to notify listeners that placement of this PF starts now planarFigure->InvokeEvent( StartPlacementPlanarFigureEvent() ); // Use Geometry2D of the renderer clicked on for this PlanarFigure mitk::PlaneGeometry *planeGeometry = const_cast< mitk::PlaneGeometry * >( dynamic_cast< const mitk::PlaneGeometry * >( renderer->GetSliceNavigationController()->GetCurrentPlaneGeometry() ) ); if ( planeGeometry != NULL ) { planarFigureGeometry = planeGeometry; planarFigure->SetGeometry2D( planeGeometry ); } else { ok = false; break; } // Extract point in 2D world coordinates (relative to Geometry2D of // PlanarFigure) Point2D point2D; if ( !this->TransformPositionEventToPoint2D( stateEvent, point2D, planarFigureGeometry ) ) { ok = false; break; } // Place PlanarFigure at this point planarFigure->PlaceFigure( point2D ); // Re-evaluate features planarFigure->EvaluateFeatures(); //this->LogPrintPlanarFigureQuantities( planarFigure ); // Set a bool property indicating that the figure has been placed in // the current RenderWindow. This is required so that the same render // window can be re-aligned to the Geometry2D of the PlanarFigure later // on in an application. m_DataNode->SetBoolProperty( "PlanarFigureInitializedWindow", true, renderer ); // Update rendered scene renderer->GetRenderingManager()->RequestUpdateAll(); ok = true; break; } case AcMOVEPOINT: { // Extract point in 2D world coordinates (relative to Geometry2D of // PlanarFigure) Point2D point2D; if ( !this->TransformPositionEventToPoint2D( stateEvent, point2D, planarFigureGeometry ) ) { ok = false; break; } // Move current control point to this point planarFigure->SetCurrentControlPoint( point2D ); // Re-evaluate features planarFigure->EvaluateFeatures(); //this->LogPrintPlanarFigureQuantities( planarFigure ); // Update rendered scene renderer->GetRenderingManager()->RequestUpdateAll(); ok = true; break; } case AcCHECKNMINUS1: { if ( planarFigure->GetNumberOfControlPoints() >= planarFigure->GetMaximumNumberOfControlPoints() ) { // Initial placement finished: deselect control point and send an // event to notify application listeners planarFigure->Modified(); planarFigure->DeselectControlPoint(); planarFigure->InvokeEvent( EndPlacementPlanarFigureEvent() ); planarFigure->InvokeEvent( EndInteractionPlanarFigureEvent() ); m_DataNode->Modified(); this->HandleEvent( new mitk::StateEvent( EIDYES, stateEvent->GetEvent() ) ); } else { this->HandleEvent( new mitk::StateEvent( EIDNO, stateEvent->GetEvent() ) ); } // Update rendered scene renderer->GetRenderingManager()->RequestUpdateAll(); ok = true; break; } case AcCHECKEQUALS1: { // NOTE: Action name is a bit misleading; this action checks whether // the figure has already the minimum number of required points to // be finished. if ( planarFigure->GetNumberOfControlPoints() >= planarFigure->GetMinimumNumberOfControlPoints() ) { // Initial placement finished: deselect control point and send an // event to notify application listeners planarFigure->Modified(); planarFigure->DeselectControlPoint(); if ( planarFigure->GetNumberOfControlPoints()-1 >= planarFigure->GetMinimumNumberOfControlPoints() ) { planarFigure->RemoveLastControlPoint(); } planarFigure->InvokeEvent( EndPlacementPlanarFigureEvent() ); planarFigure->InvokeEvent( EndInteractionPlanarFigureEvent() ); m_DataNode->Modified(); this->HandleEvent( new mitk::StateEvent( EIDYES, NULL ) ); } else { this->HandleEvent( new mitk::StateEvent( EIDNO, NULL ) ); } // Update rendered scene renderer->GetRenderingManager()->RequestUpdateAll(); ok = true; break; } case AcCHECKPOINT: { // Check if the distance of the current point to the previously set point in display coordinates // is sufficient (if a previous point exists) // Extract display position const mitk::PositionEvent *positionEvent = dynamic_cast< const mitk::PositionEvent * > ( stateEvent->GetEvent() ); if ( positionEvent == NULL ) { ok = false; break; } // Get current display position of the mouse mitk::Point2D currentDisplayPosition = positionEvent->GetDisplayPosition(); // Check if a previous point has been set int previousIndex = planarFigure->GetNumberOfControlPoints() - 2; if ( previousIndex >= 0 ) { // Try to convert previous point to current display coordinates mitk::Point3D previousPoint3D; planarFigureGeometry->Map( planarFigure->GetControlPoint( previousIndex ), previousPoint3D ); if ( renderer->GetDisplayGeometry()->Distance( previousPoint3D ) < 0.1 ) { mitk::Point2D previousDisplayPosition; projectionPlane->Map( previousPoint3D, previousDisplayPosition ); renderer->GetDisplayGeometry()->WorldToDisplay( previousDisplayPosition, previousDisplayPosition ); double a = currentDisplayPosition[0] - previousDisplayPosition[0]; double b = currentDisplayPosition[1] - previousDisplayPosition[1]; // If point is to close, do not set a new point if ( a * a + b * b < 25.0 ) { this->HandleEvent( new mitk::StateEvent( EIDNO, stateEvent->GetEvent() ) ); ok = true; break; } } } this->HandleEvent( new mitk::StateEvent( EIDYES, stateEvent->GetEvent() ) ); ok = true; break; } case AcADDPOINT: { // Extract point in 2D world coordinates (relative to Geometry2D of // PlanarFigure) Point2D point2D; if ( !this->TransformPositionEventToPoint2D( stateEvent, point2D, planarFigureGeometry ) ) { ok = false; break; } // Add point as new control point planarFigure->AddControlPoint( point2D ); // Re-evaluate features planarFigure->EvaluateFeatures(); //this->LogPrintPlanarFigureQuantities( planarFigure ); // Update rendered scene renderer->GetRenderingManager()->RequestUpdateAll(); ok = true; break; } case AcDESELECTPOINT: { planarFigure->DeselectControlPoint(); // Issue event so that listeners may update themselves planarFigure->Modified(); planarFigure->InvokeEvent( EndInteractionPlanarFigureEvent() ); m_DataNode->Modified(); // falls through } case AcCHECKSELECTED: { bool isHovering = mitk::PlanarFigureInteractor::IsPositionOverFigure( stateEvent, planarFigure, planarFigureGeometry, projectionPlane, renderer->GetDisplayGeometry() ); int pointIndex = mitk::PlanarFigureInteractor::IsPositionInsideMarker( stateEvent, planarFigure, planarFigureGeometry, projectionPlane, renderer->GetDisplayGeometry() ); + int initiallySelectedControlPoint = planarFigure->GetSelectedControlPoint(); + if ( pointIndex >= 0 ) { // If mouse is above control point, mark it as selected planarFigure->SelectControlPoint( pointIndex ); // If mouse is hovering above a marker, it is also hovering above the figure isHovering = true; } else { // Mouse in not above control point --> deselect point planarFigure->DeselectControlPoint(); } + bool renderingUpdateNeeded = false; if ( isHovering ) { if ( !m_IsHovering ) { // Invoke hover event once when the mouse is entering the figure area m_IsHovering = true; planarFigure->InvokeEvent( StartHoverPlanarFigureEvent() ); // Set bool property to indicate that planar figure is currently in "hovering" mode m_DataNode->SetBoolProperty( "planarfigure.ishovering", true ); - renderer->GetRenderingManager()->RequestUpdateAll(); + renderingUpdateNeeded = true; + } + + if ( planarFigure->GetSelectedControlPoint() != initiallySelectedControlPoint ) + { + // the selected control point has changed -> rendering update necessary + renderingUpdateNeeded = true; } this->HandleEvent( new mitk::StateEvent( EIDYES, NULL ) ); // Return true: only this interactor is eligible to react on this event ok = true; } else { if ( m_IsHovering ) { // Invoke end-hover event once the mouse is exiting the figure area m_IsHovering = false; planarFigure->InvokeEvent( EndHoverPlanarFigureEvent() ); // Set bool property to indicate that planar figure is no longer in "hovering" mode m_DataNode->SetBoolProperty( "planarfigure.ishovering", false ); - renderer->GetRenderingManager()->RequestUpdateAll(); + renderingUpdateNeeded = true; } this->HandleEvent( new mitk::StateEvent( EIDNO, NULL ) ); // Return false so that other (PlanarFigure) Interactors may react on this // event as well ok = false; } - // Update rendered scene - //renderer->GetRenderingManager()->RequestUpdateAll(); + // Update rendered scene if necessray + if ( renderingUpdateNeeded ) + { + renderer->GetRenderingManager()->RequestUpdateAll(); + } break; } case AcSELECTPICKEDOBJECT: { // Invoke event to notify listeners that this planar figure should be selected planarFigure->InvokeEvent( SelectPlanarFigureEvent() ); // Check if planar figure is marked as "editable" bool isEditable = true; m_DataNode->GetBoolProperty( "planarfigure.iseditable", isEditable ); int pointIndex = -1; if ( isEditable ) { // If planar figure is editable, check if mouse is over a control point pointIndex = mitk::PlanarFigureInteractor::IsPositionInsideMarker( stateEvent, planarFigure, planarFigureGeometry, projectionPlane, renderer->GetDisplayGeometry() ); } // If editing is enabled and the mouse is currently over a control point, select it if ( pointIndex >= 0 ) { this->HandleEvent( new mitk::StateEvent( EIDYES, NULL ) ); // Return true: only this interactor is eligible to react on this event ok = true; } else { this->HandleEvent( new mitk::StateEvent( EIDNO, NULL ) ); // Return false so that other (PlanarFigure) Interactors may react on this // event as well ok = false; } ok = true; break; } case AcSELECTPOINT: { // Invoke event to notify listeners that interaction with this PF starts now planarFigure->InvokeEvent( StartInteractionPlanarFigureEvent() ); // Reset the PlanarFigure if required if ( planarFigure->ResetOnPointSelect() ) { this->HandleEvent( new mitk::StateEvent( EIDYES, stateEvent->GetEvent() ) ); } else { this->HandleEvent( new mitk::StateEvent( EIDNO, stateEvent->GetEvent() ) ); } ok = true; break; } //case AcMOVEPOINT: //case AcMOVESELECTED: // { // // Update the display // renderer->GetRenderingManager()->RequestUpdateAll(); // ok = true; // break; // } //case AcFINISHMOVE: // { // ok = true; // break; // } default: return Superclass::ExecuteAction( action, stateEvent ); } return ok; } bool mitk::PlanarFigureInteractor::TransformPositionEventToPoint2D( const StateEvent *stateEvent, Point2D &point2D, const Geometry2D *planarFigureGeometry ) { // Extract world position, and from this position on geometry, if // available const mitk::PositionEvent *positionEvent = dynamic_cast< const mitk::PositionEvent * > ( stateEvent->GetEvent() ); if ( positionEvent == NULL ) { return false; } mitk::Point3D worldPoint3D = positionEvent->GetWorldPosition(); // TODO: proper handling of distance tolerance if ( planarFigureGeometry->Distance( worldPoint3D ) > 0.1 ) { return false; } // Project point onto plane of this PlanarFigure planarFigureGeometry->Map( worldPoint3D, point2D ); return true; } bool mitk::PlanarFigureInteractor::TransformObjectToDisplay( const mitk::Point2D &point2D, mitk::Point2D &displayPoint, const mitk::Geometry2D *objectGeometry, const mitk::Geometry2D *rendererGeometry, const mitk::DisplayGeometry *displayGeometry ) const { mitk::Point3D point3D; // Map circle point from local 2D geometry into 3D world space objectGeometry->Map( point2D, point3D ); // TODO: proper handling of distance tolerance if ( displayGeometry->Distance( point3D ) < 0.1 ) { // Project 3D world point onto display geometry rendererGeometry->Map( point3D, displayPoint ); displayGeometry->WorldToDisplay( displayPoint, displayPoint ); return true; } return false; } bool mitk::PlanarFigureInteractor::IsPointNearLine( const mitk::Point2D& point, const mitk::Point2D& startPoint, const mitk::Point2D& endPoint ) const { mitk::Vector2D n1 = endPoint - startPoint; n1.Normalize(); // Determine dot products between line vector and startpoint-point / endpoint-point vectors double l1 = n1 * (point - startPoint); double l2 = -n1 * (point - endPoint); // Determine projection of specified point onto line defined by start / end point mitk::Point2D crossPoint = startPoint + n1 * l1; // Point is inside encompassing rectangle IF // - its distance to its projected point is small enough // - it is not further outside of the line than the defined tolerance if ( (crossPoint.SquaredEuclideanDistanceTo( point ) < 20.0 ) && ( l1 > -5.0 ) && ( l2 > -5.0 ) ) { return true; } return false; } bool mitk::PlanarFigureInteractor::IsPositionOverFigure( const StateEvent *stateEvent, PlanarFigure *planarFigure, const Geometry2D *planarFigureGeometry, const Geometry2D *rendererGeometry, const DisplayGeometry *displayGeometry ) const { // Extract display position const mitk::PositionEvent *positionEvent = dynamic_cast< const mitk::PositionEvent * > ( stateEvent->GetEvent() ); if ( positionEvent == NULL ) { return -1; } mitk::Point2D displayPosition = positionEvent->GetDisplayPosition(); // Iterate over all polylines of planar figure, and check if // any one is close to the current display position typedef mitk::PlanarFigure::VertexContainerType VertexContainerType; mitk::Point2D worldPoint2D, displayControlPoint; mitk::Point3D worldPoint3D; for ( unsigned short loop = 0; loop < planarFigure->GetPolyLinesSize(); ++loop ) { const VertexContainerType* polyLine = planarFigure->GetPolyLine( loop ); Point2D polyLinePoint; Point2D firstPolyLinePoint; Point2D previousPolyLinePoint; bool firstPoint = true; for ( VertexContainerType::ConstIterator it = polyLine->Begin(); it != polyLine->End(); ++it ) { // Get plane coordinates of this point of polyline (if possible) if ( !this->TransformObjectToDisplay( it->Value(), polyLinePoint, planarFigureGeometry, rendererGeometry, displayGeometry ) ) { break; // Poly line invalid (not on current 2D plane) --> skip it } if ( firstPoint ) { firstPolyLinePoint = polyLinePoint; firstPoint = false; } else if ( this->IsPointNearLine( displayPosition, previousPolyLinePoint, polyLinePoint ) ) { // Return true if the display position is close enough to this line segment return true; } previousPolyLinePoint = polyLinePoint; } // For closed figures, also check last line segment if ( planarFigure->IsClosed() && this->IsPointNearLine( displayPosition, polyLinePoint, firstPolyLinePoint ) ) { return true; } } return false; } int mitk::PlanarFigureInteractor::IsPositionInsideMarker( const StateEvent *stateEvent, const PlanarFigure *planarFigure, const Geometry2D *planarFigureGeometry, const Geometry2D *rendererGeometry, const DisplayGeometry *displayGeometry ) const { // Extract display position const mitk::PositionEvent *positionEvent = dynamic_cast< const mitk::PositionEvent * > ( stateEvent->GetEvent() ); if ( positionEvent == NULL ) { return -1; } mitk::Point2D displayPosition = positionEvent->GetDisplayPosition(); // Iterate over all control points of planar figure, and check if // any one is close to the current display position typedef mitk::PlanarFigure::VertexContainerType VertexContainerType; const VertexContainerType *controlPoints = planarFigure->GetControlPoints(); mitk::Point2D worldPoint2D, displayControlPoint; mitk::Point3D worldPoint3D; VertexContainerType::ConstIterator it; for ( it = controlPoints->Begin(); it != controlPoints->End(); ++it ) { Point2D displayControlPoint; if ( this->TransformObjectToDisplay( it->Value(), displayControlPoint, planarFigureGeometry, rendererGeometry, displayGeometry ) ) { // TODO: variable size of markers if ( (abs(displayPosition[0] - displayControlPoint[0]) < 4 ) && (abs(displayPosition[1] - displayControlPoint[1]) < 4 ) ) { return it->Index(); } } } return -1; } void mitk::PlanarFigureInteractor::LogPrintPlanarFigureQuantities( const PlanarFigure *planarFigure ) { MITK_INFO << "PlanarFigure: " << planarFigure->GetNameOfClass(); for ( unsigned int i = 0; i < planarFigure->GetNumberOfFeatures(); ++i ) { MITK_INFO << "* " << planarFigure->GetFeatureName( i ) << ": " << planarFigure->GetQuantity( i ) << " " << planarFigure->GetFeatureUnit( i ); } } diff --git a/Modules/RigidRegistration/CMakeLists.txt b/Modules/RigidRegistration/CMakeLists.txt index 4509e89ae1..1618ef4b52 100644 --- a/Modules/RigidRegistration/CMakeLists.txt +++ b/Modules/RigidRegistration/CMakeLists.txt @@ -1,7 +1,8 @@ MITK_CREATE_MODULE(MitkRigidRegistration + SUBPROJECTS MITK-Registration DEPENDS Mitk PROVIDES MitkRigidRegistration EXPORT_DEFINE MITK_RIGIDREGISTRATION_EXPORT ) ADD_SUBDIRECTORY(Testing) diff --git a/Modules/RigidRegistrationUI/CMakeLists.txt b/Modules/RigidRegistrationUI/CMakeLists.txt index 8c7f048517..8eb8586bc6 100644 --- a/Modules/RigidRegistrationUI/CMakeLists.txt +++ b/Modules/RigidRegistrationUI/CMakeLists.txt @@ -1,7 +1,8 @@ MITK_CREATE_MODULE(MitkRigidRegistrationUI + SUBPROJECTS MITK-Registration INCLUDE_DIRS RigidRegistrationMetrics RigidRegistrationOptimizer RigidRegistrationTransforms DEPENDS Qmitk MitkRigidRegistration QT_MODULE PROVIDES MitkRigidRegistrationUI EXPORT_DEFINE MITK_RIGIDREGISTRATION_UI_EXPORT ) diff --git a/SuperBuild.cmake b/SuperBuild.cmake index 96b3edfc5c..e171c5adfc 100644 --- a/SuperBuild.cmake +++ b/SuperBuild.cmake @@ -1,231 +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_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} ${OpenCV_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} 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 ) - +