diff --git a/CMake/PackageDepends/MITK_DCMTK_Config.cmake b/CMake/PackageDepends/MITK_DCMTK_Config.cmake index 4a1bd503a5..bdaebe6426 100644 --- a/CMake/PackageDepends/MITK_DCMTK_Config.cmake +++ b/CMake/PackageDepends/MITK_DCMTK_Config.cmake @@ -1,48 +1,48 @@ IF(MITK_USE_DCMTK) IF(NOT DCMTK_DIR) SET(DCMTK_DIR "$ENV{DCMTK_DIR}" CACHE PATH "Location of DCMTK") SET(DCMTK_DIR "$ENV{DCMTK_DIR}") IF(NOT DCMTK_DIR) MESSAGE(FATAL_ERROR "DCMTK_DIR not set. Cannot proceed.") ENDIF(NOT DCMTK_DIR) ENDIF(NOT DCMTK_DIR) FIND_PACKAGE(DCMTK) IF(NOT DCMTK_FOUND) MESSAGE(SEND_ERROR "DCMTK development files not found.\n Please check variables (e.g. DCMTK_DIR) for include directories and libraries.\nYou may set environment variable DCMTK_DIR before pressing 'configure'") ENDIF(NOT DCMTK_FOUND) IF( NOT WIN32 ) SET(MISSING_LIBS_REQUIRED_BY_DCMTK wrap tiff) ENDIF( NOT WIN32 ) SET(QT_USE_QTSQL 1) IF(EXISTS ${DCMTK_config_INCLUDE_DIR}/osconfig.h) FILE(READ ${DCMTK_config_INCLUDE_DIR}/osconfig.h _osconfig_h) IF(NOT _osconfig_h MATCHES "PACKAGE_VERSION_NUMBER \"354\"") - MESSAGE(STATUS "Found DCMTK newer that 3.5.4 ...") + # MESSAGE(STATUS "Found DCMTK newer that 3.5.4 ...") SET(MITK_USE_DCMTK_NEWER_THAN_3_5_4 TRUE) # assume the new oflog library is located next to the others # this can be removed if FindDCMTK is adapted for 3.5.5 GET_FILENAME_COMPONENT(_DCMTK_lib_dir ${DCMTK_ofstd_LIBRARY} PATH) FIND_LIBRARY(DCMTK_oflog_LIBRARY oflog ${_DCMTK_lib_dir} ) LIST(APPEND DCMTK_LIBRARIES ${DCMTK_oflog_LIBRARY}) ENDIF(NOT _osconfig_h MATCHES "PACKAGE_VERSION_NUMBER \"354\"") ENDIF(EXISTS ${DCMTK_config_INCLUDE_DIR}/osconfig.h) # # Usually all code should be adapted to DCMTK 3.6 # If necessary you could configure the MITK_USE_DCMTK_NEWER_THAN_3_5_4 variable # to configure a header file for ifdefs: # CONFIGURE_FILE( mitkDCMTKConfig.h.in mitkDCMTKConfig.h ) LIST(APPEND ALL_INCLUDE_DIRECTORIES ${DCMTK_INCLUDE_DIR} ${DCMTK_DIR}/include) LIST(APPEND ALL_LIBRARIES ${DCMTK_LIBRARIES} ${MISSING_LIBS_REQUIRED_BY_DCMTK}) #link_directories() ENDIF(MITK_USE_DCMTK) diff --git a/CMake/mitkMacroCreateModule.cmake b/CMake/mitkMacroCreateModule.cmake index d88fa16266..ad8cd0f1c5 100644 --- a/CMake/mitkMacroCreateModule.cmake +++ b/CMake/mitkMacroCreateModule.cmake @@ -1,197 +1,208 @@ ################################################################## # # MITK_CREATE_MODULE # #! Creates a module for the automatic module dependency system within MITK. #! Configurations are generated in the moduleConf directory. #! #! USAGE: #! #! \code #! MITK_CREATE_MODULE( #! [INCLUDE_DIRS ] #! [INTERNAL_INCLUDE_DIRS ] #! [DEPENDS ] #! [PROVIDES ] #! [PACKAGE_DEPENDS ] #! [EXPORT_DEFINE ] #! [QT_MODULE] #! \endcode #! #! \param MODULE_NAME_IN The name for the new module # ################################################################## MACRO(MITK_CREATE_MODULE MODULE_NAME_IN) MACRO_PARSE_ARGUMENTS(MODULE "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} - ) + # first we check if we have an explicit module build list + IF(MITK_MODULES_TO_BUILD) + LIST(FIND MITK_MODULES_TO_BUILD ${MODULE_NAME} _MOD_INDEX) + IF(_MOD_INDEX EQUAL -1) + SET(MODULE_IS_EXCLUDED 1) + ENDIF() + ENDIF() + IF(NOT MODULE_IS_EXCLUDED) + # 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(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} ${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) + 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} ${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) - IF(MINGW) - TARGET_LINK_LIBRARIES(${MODULE_PROVIDES} ssp) # add stack smash protection lib - ENDIF() - ENDIF() - - ELSE(NOT MODULE_QT_MODULE) + IF(MINGW) + TARGET_LINK_LIBRARIES(${MODULE_PROVIDES} ssp) # add stack smash protection lib + ENDIF() + 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}) + 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") + # 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} ${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(MINGW) - TARGET_LINK_LIBRARIES(${MODULE_PROVIDES} ssp) # add stack smash protection lib - ENDIF() - 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) + 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} ${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(MINGW) + TARGET_LINK_LIBRARIES(${MODULE_PROVIDES} ssp) # add stack smash protection lib + ENDIF() + 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() + #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) - + # 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) + ENDIF(NOT MODULE_IS_EXCLUDED) + IF(NOT MODULE_IS_ENABLED) _MITK_CREATE_MODULE_CONF() ENDIF(NOT MODULE_IS_ENABLED) ENDMACRO(MITK_CREATE_MODULE) diff --git a/Core/Code/Testing/DICOMTesting/CMakeLists.txt b/Core/Code/Testing/DICOMTesting/CMakeLists.txt index 5cf1837afb..e5ae20d32f 100644 --- a/Core/Code/Testing/DICOMTesting/CMakeLists.txt +++ b/Core/Code/Testing/DICOMTesting/CMakeLists.txt @@ -1,33 +1,38 @@ if (BUILD_TESTING) if (GDCM_DIR) # clear variables from prior files.cmake set(MODULE_TESTS) set(MODULE_IMAGE_TESTS) set(MODULE_TESTIMAGES) set(MODULE_CUSTOM_TESTS) set(H_FILES) set(CPP_FILES) # now create a new module only for testing purposes MITK_CREATE_MODULE( mitkDICOMTesting DEPENDS Mitk # mitkCore.so ) +MITK_CHECK_MODULE(_RESULT mitkDICOMTesting) +IF(_RESULT) + MESSAGE(STATUS "mitkDICOMTesting application won't be built. Missing: ${_RESULT}") +ELSE(_RESULT) # add helpful applications MITK_USE_MODULE( mitkDICOMTesting ) include_directories(${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR} ${ALL_INCLUDE_DIRECTORIES}) # dumps out image information add_executable(DumpDICOMMitkImage DumpDICOMMitkImage.cpp) target_link_libraries(DumpDICOMMitkImage ${ALL_LIBRARIES}) # compares dumped out image information against reference dump add_executable(VerifyDICOMMitkImageDump VerifyDICOMMitkImageDump.cpp) target_link_libraries(VerifyDICOMMitkImageDump ${ALL_LIBRARIES}) add_subdirectory(Testing) +ENDIF() endif() endif() diff --git a/Modules/IGT/CMakeLists.txt b/Modules/IGT/CMakeLists.txt index 86c067a85e..f01dd52f60 100644 --- a/Modules/IGT/CMakeLists.txt +++ b/Modules/IGT/CMakeLists.txt @@ -1,30 +1,37 @@ 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}" ) + +MITK_CHECK_MODULE(_RESULT MitkIGT) +IF(_RESULT) + MESSAGE(STATUS "IGTTutorialStep1 won't be built. Missing: ${_RESULT}") +ELSE(_RESULT) ## 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) +ENDIF(_RESULT) + diff --git a/SuperBuild.cmake b/SuperBuild.cmake index a433482fa9..65fccf4c57 100644 --- a/SuperBuild.cmake +++ b/SuperBuild.cmake @@ -1,241 +1,245 @@ #----------------------------------------------------------------------------- # 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 MITKData ) # Include external projects FOREACH(p ${external_projects}) INCLUDE(CMakeExternals/${p}.cmake) ENDFOREACH() #----------------------------------------------------------------------------- # Set superbuild boolean args #----------------------------------------------------------------------------- SET(mitk_cmake_boolean_args BUILD_SHARED_LIBS WITH_COVERAGE BUILD_TESTING MITK_USE_QT MITK_INSTALL_RPATH_RELATIVE MITK_BUILD_ALL_PLUGINS MITK_BUILD_TUTORIAL MITK_USE_Boost MITK_USE_BLUEBERRY MITK_USE_CTK MITK_USE_DCMTK MITK_USE_OpenCV ) #----------------------------------------------------------------------------- # 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-Data_DEPENDS} ) #----------------------------------------------------------------------------- # MITK Configure #----------------------------------------------------------------------------- IF(MITK_INITIAL_CACHE_FILE) SET(mitk_initial_cache_arg -C "${MITK_INITIAL_CACHE_FILE}") ENDIF() SET(proj MITK-Configure) +STRING(REPLACE ";" "^^" MITK_MODULES_TO_BUILD_PARAM "${MITK_MODULES_TO_BUILD}") +MESSAGE("PARAM: ${MITK_MODULES_TO_BUILD_PARAM}") ExternalProject_Add(${proj} + LIST_SEPARATOR ^^ DOWNLOAD_COMMAND "" CMAKE_GENERATOR ${gen} CMAKE_ARGS ${ep_common_args} ${mitk_superbuild_boolean_args} -DMITK_USE_SUPERBUILD:BOOL=OFF -DMITK_CMAKE_LIBRARY_OUTPUT_DIRECTORY:PATH=${MITK_CMAKE_LIBRARY_OUTPUT_DIRECTORY} -DMITK_CMAKE_RUNTIME_OUTPUT_DIRECTORY:PATH=${MITK_CMAKE_RUNTIME_OUTPUT_DIRECTORY} -DMITK_CMAKE_ARCHIVE_OUTPUT_DIRECTORY:PATH=${MITK_CMAKE_ARCHIVE_OUTPUT_DIRECTORY} -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} + -DMITK_MODULES_TO_BUILD:INTERNAL=${MITK_MODULES_TO_BUILD_PARAM} -DCTK_DIR:PATH=${CTK_DIR} -DDCMTK_DIR:PATH=${DCMTK_DIR} -DVTK_DIR:PATH=${VTK_DIR} # FindVTK expects VTK_DIR -DITK_DIR:PATH=${ITK_DIR} # FindITK expects ITK_DIR -DOpenCV_DIR:PATH=${OpenCV_DIR} -DGDCM_DIR:PATH=${GDCM_DIR} -DBOOST_ROOT:PATH=${BOOST_ROOT} -DMITK_DATA_DIR:PATH=${MITK_DATA_DIR} ${mitk_initial_cache_arg} 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 )