diff --git a/Applications/PluginGenerator/ProjectTemplate/CMakeExternals/MITK.cmake b/Applications/PluginGenerator/ProjectTemplate/CMakeExternals/MITK.cmake index c0cacdae5e..3a73aa3e16 100644 --- a/Applications/PluginGenerator/ProjectTemplate/CMakeExternals/MITK.cmake +++ b/Applications/PluginGenerator/ProjectTemplate/CMakeExternals/MITK.cmake @@ -1,217 +1,213 @@ #----------------------------------------------------------------------------- # MITK #----------------------------------------------------------------------------- set(MITK_DEPENDS) set(proj_DEPENDENCIES) set(proj MITK) if(NOT MITK_DIR) #----------------------------------------------------------------------------- # Create CMake options to customize the MITK build #----------------------------------------------------------------------------- option(MITK_USE_SUPERBUILD "Use superbuild for MITK" ON) option(MITK_USE_BLUEBERRY "Build the BlueBerry platform in MITK" ON) option(MITK_BUILD_EXAMPLES "Build the MITK examples" OFF) option(MITK_BUILD_ALL_PLUGINS "Build all MITK plugins" OFF) option(MITK_BUILD_TESTING "Build the MITK unit tests" OFF) option(MITK_USE_ACVD "Use Approximated Centroidal Voronoi Diagrams" OFF) option(MITK_USE_CTK "Use CTK in MITK" ${MITK_USE_BLUEBERRY}) option(MITK_USE_DCMTK "Use DCMTK in MITK" ON) option(MITK_USE_QT "Use Nokia's Qt library in MITK" ON) option(MITK_USE_Boost "Use the Boost library in MITK" OFF) option(MITK_USE_OpenCV "Use Intel's OpenCV library" OFF) option(MITK_USE_SOFA "Use Simulation Open Framework Architecture" OFF) option(MITK_USE_Python "Enable Python wrapping in MITK" OFF) if(MITK_USE_BLUEBERRY AND NOT MITK_USE_CTK) message("Forcing MITK_USE_CTK to ON because of MITK_USE_BLUEBERRY") set(MITK_USE_CTK ON CACHE BOOL "Use CTK in MITK" FORCE) endif() if(MITK_USE_CTK AND NOT MITK_USE_QT) message("Forcing MITK_USE_QT to ON because of MITK_USE_CTK") set(MITK_USE_QT ON CACHE BOOL "Use Nokia's Qt library in MITK" FORCE) endif() set(MITK_USE_CableSwig ${MITK_USE_Python}) set(MITK_USE_GDCM 1) set(MITK_USE_ITK 1) set(MITK_USE_VTK 1) mark_as_advanced(MITK_USE_SUPERBUILD MITK_BUILD_ALL_PLUGINS MITK_BUILD_TESTING ) set(mitk_cmake_boolean_args MITK_USE_SUPERBUILD MITK_USE_BLUEBERRY MITK_BUILD_EXAMPLES MITK_BUILD_ALL_PLUGINS MITK_USE_ACVD MITK_USE_CTK MITK_USE_DCMTK MITK_USE_QT MITK_USE_Boost MITK_USE_OpenCV MITK_USE_SOFA MITK_USE_Python ) if(MITK_USE_QT) # Look for Qt at the superbuild level, to catch missing Qt libs early find_package(Qt4 4.7 REQUIRED) endif() set(additional_mitk_cmakevars ) # Configure the set of default pixel types set(MITK_ACCESSBYITK_INTEGRAL_PIXEL_TYPES "int, unsigned int, short, unsigned short, char, unsigned char" CACHE STRING "List of integral pixel types used in AccessByItk and InstantiateAccessFunction macros") set(MITK_ACCESSBYITK_FLOATING_PIXEL_TYPES "double, float" CACHE STRING "List of floating pixel types used in AccessByItk and InstantiateAccessFunction macros") set(MITK_ACCESSBYITK_COMPOSITE_PIXEL_TYPES "" CACHE STRING "List of composite pixel types used in AccessByItk and InstantiateAccessFunction macros") set(MITK_ACCESSBYITK_DIMENSIONS "2,3" CACHE STRING "List of dimensions used in AccessByItk and InstantiateAccessFunction macros") foreach(_arg MITK_ACCESSBYITK_INTEGRAL_PIXEL_TYPES MITK_ACCESSBYITK_FLOATING_PIXEL_TYPES MITK_ACCESSBYITK_COMPOSITE_PIXEL_TYPES MITK_ACCESSBYITK_DIMENSIONS) mark_as_advanced(${_arg}) list(APPEND additional_mitk_cmakevars "-D${_arg}:STRING=${${_arg}}") endforeach() #----------------------------------------------------------------------------- # Create options to inject pre-build dependencies #----------------------------------------------------------------------------- foreach(proj CTK DCMTK GDCM VTK ACVD ITK OpenCV SOFA CableSwig) if(MITK_USE_${proj}) set(MITK_${proj}_DIR "${${proj}_DIR}" CACHE PATH "Path to ${proj} build directory") mark_as_advanced(MITK_${proj}_DIR) if(MITK_${proj}_DIR) list(APPEND additional_mitk_cmakevars "-D${proj}_DIR:PATH=${MITK_${proj}_DIR}") endif() endif() endforeach() if(MITK_USE_Boost) set(MITK_BOOST_ROOT "${BOOST_ROOT}" CACHE PATH "Path to Boost directory") mark_as_advanced(MITK_BOOST_ROOT) if(MITK_BOOST_ROOT) list(APPEND additional_mitk_cmakevars "-DBOOST_ROOT:PATH=${MITK_BOOST_ROOT}") endif() endif() set(MITK_SOURCE_DIR "" CACHE PATH "MITK source code location. If empty, MITK will be cloned from MITK_GIT_REPOSITORY") set(MITK_GIT_REPOSITORY "http://git.mitk.org/MITK.git" CACHE STRING "The git repository for cloning MITK") set(MITK_GIT_TAG "releases/master" CACHE STRING "The git tag/hash to be used when cloning from MITK_GIT_REPOSITORY") mark_as_advanced(MITK_SOURCE_DIR MITK_GIT_REPOSITORY MITK_GIT_TAG) #----------------------------------------------------------------------------- # Create the final variable containing superbuild boolean args #----------------------------------------------------------------------------- set(mitk_boolean_args) foreach(mitk_cmake_arg ${mitk_cmake_boolean_args}) list(APPEND mitk_boolean_args -D${mitk_cmake_arg}:BOOL=${${mitk_cmake_arg}}) endforeach() #----------------------------------------------------------------------------- # Additional MITK CMake variables #----------------------------------------------------------------------------- if(MITK_USE_QT AND QT_QMAKE_EXECUTABLE) list(APPEND additional_mitk_cmakevars "-DQT_QMAKE_EXECUTABLE:FILEPATH=${QT_QMAKE_EXECUTABLE}") endif() if(MITK_USE_CTK) list(APPEND additional_mitk_cmakevars "-DGIT_EXECUTABLE:FILEPATH=${GIT_EXECUTABLE}") endif() if(MITK_INITIAL_CACHE_FILE) list(APPEND additional_mitk_cmakevars "-DMITK_INITIAL_CACHE_FILE:INTERNAL=${MITK_INITIAL_CACHE_FILE}") endif() if(MITK_USE_SUPERBUILD) set(MITK_BINARY_DIR ${proj}-superbuild) else() set(MITK_BINARY_DIR ${proj}-build) endif() set(proj_DEPENDENCIES) set(MITK_DEPENDS ${proj}) # Configure the MITK souce code location if(NOT MITK_SOURCE_DIR) set(mitk_source_location SOURCE_DIR ${CMAKE_BINARY_DIR}/${proj} GIT_REPOSITORY ${MITK_GIT_REPOSITORY} GIT_TAG ${MITK_GIT_TAG} ) else() set(mitk_source_location SOURCE_DIR ${MITK_SOURCE_DIR} ) endif() ExternalProject_Add(${proj} ${mitk_source_location} BINARY_DIR ${MITK_BINARY_DIR} PREFIX ${proj}${ep_suffix} INSTALL_COMMAND "" CMAKE_GENERATOR ${gen} CMAKE_ARGS ${ep_common_args} ${mitk_boolean_args} ${additional_mitk_cmakevars} -DBUILD_SHARED_LIBS:BOOL=ON -DBUILD_TESTING:BOOL=${MITK_BUILD_TESTING} DEPENDS ${proj_DEPENDENCIES} ) if(MITK_USE_SUPERBUILD) set(MITK_DIR "${CMAKE_CURRENT_BINARY_DIR}/${MITK_BINARY_DIR}/MITK-build") else() set(MITK_DIR "${CMAKE_CURRENT_BINARY_DIR}/${MITK_BINARY_DIR}") endif() else() # The project is provided using MITK_DIR, nevertheless since other # projects may depend on MITK, let's add an 'empty' one MacroEmptyExternalProject(${proj} "${proj_DEPENDENCIES}") # Further, do some sanity checks in the case of a pre-built MITK set(my_itk_dir ${ITK_DIR}) set(my_vtk_dir ${VTK_DIR}) set(my_qmake_executable ${QT_QMAKE_EXECUTABLE}) find_package(MITK REQUIRED) if(my_itk_dir AND NOT my_itk_dir STREQUAL ${ITK_DIR}) message(FATAL_ERROR "ITK packages do not match:\n ${MY_PROJECT_NAME}: ${my_itk_dir}\n MITK: ${ITK_DIR}") endif() if(my_vtk_dir AND NOT my_vtk_dir STREQUAL ${VTK_DIR}) message(FATAL_ERROR "VTK packages do not match:\n ${MY_PROJECT_NAME}: ${my_vtk_dir}\n MITK: ${VTK_DIR}") endif() - if(my_qmake_executable AND NOT my_qmake_executable STREQUAL ${MITK_QMAKE_EXECUTABLE}) - message(FATAL_ERROR "Qt qmake does not match:\n ${MY_PROJECT_NAME}: ${my_qmake_executable}\n MITK: ${MITK_QMAKE_EXECUTABLE}") - endif() - endif() diff --git a/CMake/FindDCMTK.cmake b/CMake/FindDCMTK.cmake index a9645504c9..ccdd2ce106 100644 --- a/CMake/FindDCMTK.cmake +++ b/CMake/FindDCMTK.cmake @@ -1,183 +1,186 @@ # adapted version of FindDCMTK, better suited for super-builds # - find DCMTK libraries and applications # # DCMTK_INCLUDE_DIRS - Directories to include to use DCMTK # DCMTK_LIBRARIES - Files to link against to use DCMTK # DCMTK_FOUND - If false, don't try to use DCMTK # DCMTK_DIR - (optional) Source directory for DCMTK # # DCMTK_DIR can be used to make it simpler to find the various include # directories and compiled libraries if you've just compiled it in the # source tree. Just set it to the root of the tree where you extracted # the source (default to /usr/include/dcmtk/) #============================================================================= # Copyright 2004-2009 Kitware, Inc. # Copyright 2009-2010 Mathieu Malaterre # Copyright 2010 Thomas Sondergaard # # Distributed under the OSI-approved BSD License (the "License"); # see accompanying file Copyright.txt for details. # # This software is distributed WITHOUT ANY WARRANTY; without even the # implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. # See the License for more information. #============================================================================= # (To distributed this file outside of CMake, substitute the full # License text for the above reference.) # # Written for VXL by Amitha Perera. # Upgraded for GDCM by Mathieu Malaterre. # Modified for EasyViz by Thomas Sondergaard. # # prefer DCMTK_DIR over default system paths like /usr/lib set(CMAKE_PREFIX_PATH ${DCMTK_DIR}/lib ${CMAKE_PREFIX_PATH}) # this is given to FIND_LIBRARY or FIND_PATH if(NOT DCMTK_FOUND AND NOT DCMTK_DIR) set(DCMTK_DIR "/usr/include/dcmtk/" CACHE PATH "Root of DCMTK source tree (optional).") mark_as_advanced(DCMTK_DIR) endif() # Find all libraries, store debug and release separately foreach(lib dcmpstat dcmsr dcmsign dcmtls dcmqrdb dcmnet dcmjpeg dcmimage dcmimgle dcmdata dcmrt oflog ofstd ijg12 ijg16 ijg8 ) # Find Release libraries find_library(DCMTK_${lib}_LIBRARY_RELEASE ${lib} PATHS ${DCMTK_DIR}/${lib}/libsrc ${DCMTK_DIR}/${lib}/libsrc/Release ${DCMTK_DIR}/${lib}/Release ${DCMTK_DIR}/lib ${DCMTK_DIR}/lib/Release ${DCMTK_DIR}/dcmjpeg/lib${lib}/Release NO_DEFAULT_PATH ) # Find Debug libraries find_library(DCMTK_${lib}_LIBRARY_DEBUG ${lib}${DCMTK_CMAKE_DEBUG_POSTFIX} PATHS ${DCMTK_DIR}/${lib}/libsrc ${DCMTK_DIR}/${lib}/libsrc/Debug ${DCMTK_DIR}/${lib}/Debug ${DCMTK_DIR}/lib ${DCMTK_DIR}/lib/Debug ${DCMTK_DIR}/dcmjpeg/lib${lib}/Debug NO_DEFAULT_PATH ) mark_as_advanced(DCMTK_${lib}_LIBRARY_RELEASE) mark_as_advanced(DCMTK_${lib}_LIBRARY_DEBUG) # Add libraries to variable according to build type set(DCMTK_${lib}_LIBRARY) if(DCMTK_${lib}_LIBRARY_RELEASE) list(APPEND DCMTK_LIBRARIES optimized ${DCMTK_${lib}_LIBRARY_RELEASE}) list(APPEND DCMTK_${lib}_LIBRARY optimized ${DCMTK_${lib}_LIBRARY_RELEASE}) endif() if(DCMTK_${lib}_LIBRARY_DEBUG) list(APPEND DCMTK_LIBRARIES debug ${DCMTK_${lib}_LIBRARY_DEBUG}) list(APPEND DCMTK_${lib}_LIBRARY debug ${DCMTK_${lib}_LIBRARY_DEBUG}) endif() endforeach() set(DCMTK_config_TEST_HEADER osconfig.h) set(DCMTK_dcmdata_TEST_HEADER dctypes.h) set(DCMTK_dcmimage_TEST_HEADER dicoimg.h) set(DCMTK_dcmimgle_TEST_HEADER dcmimage.h) set(DCMTK_dcmjpeg_TEST_HEADER djdecode.h) set(DCMTK_dcmnet_TEST_HEADER assoc.h) set(DCMTK_dcmpstat_TEST_HEADER dcmpstat.h) set(DCMTK_dcmqrdb_TEST_HEADER dcmqrdba.h) set(DCMTK_dcmsign_TEST_HEADER sicert.h) set(DCMTK_dcmsr_TEST_HEADER dsrtree.h) set(DCMTK_dcmtls_TEST_HEADER tlslayer.h) set(DCMTK_ofstd_TEST_HEADER ofstdinc.h) set(DCMTK_dcmrt_TEST_HEADER drtstrct.h) foreach(dir config dcmdata dcmimage dcmimgle dcmjpeg dcmnet dcmpstat dcmqrdb dcmsign dcmsr dcmtls dcmrt ofstd) find_path(DCMTK_${dir}_INCLUDE_DIR ${DCMTK_${dir}_TEST_HEADER} PATHS ${DCMTK_DIR}/${dir}/include ${DCMTK_DIR}/${dir} ${DCMTK_DIR}/include/dcmtk/${dir} ${DCMTK_DIR}/include/${dir}) mark_as_advanced(DCMTK_${dir}_INCLUDE_DIR) #message("** DCMTKs ${dir} found at ${DCMTK_${dir}_INCLUDE_DIR}") if(DCMTK_${dir}_INCLUDE_DIR) - list(APPEND - DCMTK_INCLUDE_DIRS - ${DCMTK_${dir}_INCLUDE_DIR}) + # add the 'include' path so eg + #include "dcmtk/dcmimgle/dcmimage.h" + # works + get_filename_component(_include ${DCMTK_${dir}_INCLUDE_DIR} PATH) + get_filename_component(_include ${_include} PATH) + list(APPEND DCMTK_INCLUDE_DIRS ${DCMTK_${dir}_INCLUDE_DIR} ${_include}) endif() endforeach() if(WIN32) list(APPEND DCMTK_LIBRARIES netapi32 wsock32) endif() if(DCMTK_ofstd_INCLUDE_DIR) get_filename_component(DCMTK_dcmtk_INCLUDE_DIR ${DCMTK_ofstd_INCLUDE_DIR} PATH CACHE) list(APPEND DCMTK_INCLUDE_DIRS ${DCMTK_dcmtk_INCLUDE_DIR}) mark_as_advanced(DCMTK_dcmtk_INCLUDE_DIR) endif() include(FindPackageHandleStandardArgs) find_package_handle_standard_args(DCMTK DEFAULT_MSG DCMTK_config_INCLUDE_DIR DCMTK_ofstd_INCLUDE_DIR DCMTK_ofstd_LIBRARY DCMTK_dcmdata_INCLUDE_DIR DCMTK_dcmdata_LIBRARY DCMTK_dcmimgle_INCLUDE_DIR DCMTK_dcmimgle_LIBRARY ) # Compatibility: This variable is deprecated set(DCMTK_INCLUDE_DIR ${DCMTK_INCLUDE_DIRS}) diff --git a/CMake/FindEigen.cmake b/CMake/FindEigen.cmake new file mode 100644 index 0000000000..2ec430484c --- /dev/null +++ b/CMake/FindEigen.cmake @@ -0,0 +1,16 @@ +find_path(Eigen_INCLUDE_DIR + NAMES Eigen/Eigen + PATHS ${Eigen_DIR} ${MITK_EXTERNAL_PROJECT_PREFIX} ${CMAKE_PREFIX_PATH} + PATH_SUFFIXES include include/eigen3 +) + +if (NOT TARGET Eigen) + add_library(Eigen INTERFACE IMPORTED GLOBAL) + set_property(TARGET Eigen APPEND PROPERTY INTERFACE_INCLUDE_DIRECTORIES ${Eigen_INCLUDE_DIR}) +endif() + +find_package_handle_standard_args(Eigen + FOUND_VAR Eigen_FOUND + REQUIRED_VARS Eigen_INCLUDE_DIR +) + diff --git a/CMake/PackageDepends/MITK_DCMTK_Config.cmake b/CMake/PackageDepends/MITK_DCMTK_Config.cmake index 4d5db9f2ef..8889ea91e4 100644 --- a/CMake/PackageDepends/MITK_DCMTK_Config.cmake +++ b/CMake/PackageDepends/MITK_DCMTK_Config.cmake @@ -1,58 +1,58 @@ 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 QUIET REQUIRED) 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 AND NOT APPLE ) set(MISSING_LIBS_REQUIRED_BY_DCMTK wrap tiff z) endif( NOT WIN32 AND NOT APPLE ) 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 ...") 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 # treat Debug and Release separately get_filename_component(_DCMTK_lib_dir_release ${DCMTK_ofstd_LIBRARY_RELEASE} PATH) get_filename_component(_DCMTK_lib_dir_debug ${DCMTK_ofstd_LIBRARY_DEBUG} PATH) set(DCMTK_oflog_LIBRARY_RELEASE ) set(DCMTK_oflog_LIBRARY_DEBUG ) if(_DCMTK_lib_dir_release) find_library(DCMTK_oflog_LIBRARY_RELEASE oflog ${_DCMTK_lib_dir_release} ) list(APPEND DCMTK_LIBRARIES optimized ${DCMTK_oflog_LIBRARY_RELEASE} ) endif() if(_DCMTK_lib_dir_debug) find_library(DCMTK_oflog_LIBRARY_DEBUG oflog ${_DCMTK_lib_dir_debug} ) list(APPEND DCMTK_LIBRARIES debug ${DCMTK_oflog_LIBRARY_DEBUG} ) endif() - endif(NOT _osconfig_h MATCHES "PACKAGE_VERSION_NUMBER \"354\"") -endif(EXISTS ${DCMTK_config_INCLUDE_DIR}/osconfig.h) + endif() +endif() # # 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_INCLUDE_DIRECTORIES ${DCMTK_INCLUDE_DIR}) list(APPEND ALL_LIBRARIES ${DCMTK_LIBRARIES} ${MISSING_LIBS_REQUIRED_BY_DCMTK}) #link_directories() -endif(MITK_USE_DCMTK) +endif() diff --git a/CMake/PackageDepends/MITK_Eigen_Config.cmake b/CMake/PackageDepends/MITK_Eigen_Config.cmake index dfd8299dd7..f75a12f0d2 100644 --- a/CMake/PackageDepends/MITK_Eigen_Config.cmake +++ b/CMake/PackageDepends/MITK_Eigen_Config.cmake @@ -1 +1,3 @@ -list(APPEND ALL_INCLUDE_DIRECTORIES ${Eigen_DIR}/include/eigen3) +find_package(Eigen REQUIRED) +list(APPEND ALL_LIBRARIES Eigen) + diff --git a/CMake/PackageDepends/MITK_Redland_Config.cmake b/CMake/PackageDepends/MITK_Redland_Config.cmake index 8269c8f356..a2d57382ab 100644 --- a/CMake/PackageDepends/MITK_Redland_Config.cmake +++ b/CMake/PackageDepends/MITK_Redland_Config.cmake @@ -1,4 +1,3 @@ -list(APPEND CMAKE_PREFIX_PATH ${REDLAND_INSTALL_DIR}) find_package(Redland REQUIRED CONFIG) list(APPEND ALL_INCLUDE_DIRECTORIES ${Redland_INCLUDE_DIR}) list(APPEND ALL_LIBRARIES rdf) diff --git a/CMake/mitkFunctionAddExternalProject.cmake b/CMake/mitkFunctionAddExternalProject.cmake new file mode 100644 index 0000000000..4fcc7b257e --- /dev/null +++ b/CMake/mitkFunctionAddExternalProject.cmake @@ -0,0 +1,86 @@ +#! Register an external project. +#! +#! Calling this function registers an external project with the MITK +#! build system. Usage: +#! +#! mitkFunctionAddExternalProject(NAME name [ON|OFF] +#! [PACKAGE package] [COMPONENTS comp1...] +#! [DEPENDS dep1...] +#! [DOC docstring] +#! [NO_CACHE] [ADVANCED] [NO_PACKAGE] +#! ) +#! +#! The function creates a MITK_USE_ internal cache variable if the +#! NO_CACHE option is given. If the NO_CACHE option is not set, a normal +#! boolean cache option is created with the given DOC argument as help string. +#! The option is marked as advanced if the ADVANCED option is set. The +#! option's initial value matches the ON or OFF option and defaults to OFF +#! is none is given. The DEPENDS arguments are used to force the +#! corresponding MITK_USE_ cache variables to ON if MITK_USE_ +#! is ON. +#! +#! The PACKAGE argument names the argument for the +#! corresponding find_package() call in MITKs top-level CMakeLists.txt +#! and MITKConfig.cmake file. It defaults to . If COMPONENTS are +#! specified, these are passed to the find_package() call. If the +#! NO_PACKAGE option is given, the find_package() call is suppressed. +#! +#! For each registered external project there must exist a file called +#! CMakeExternals/.cmake which defines the build process for +#! the external project. +#! +#! \note Note that multiple calls of this function must be ordered +#! relative to their declared dependencies. This applies to the DEPENDS +#! arguments of this function as well as the actual target dependencies +#! declared in the CMakeExternals/.cmake file. +#! +function(mitkFunctionAddExternalProject) + cmake_parse_arguments(EP "ON;OFF;NO_CACHE;ADVANCED;NO_PACKAGE" "NAME;DOC;PACKAGE" "DEPENDS;COMPONENTS" ${ARGN}) + if(NOT EP_NAME) + message(SEND_ERROR "The NAME argument is missing.") + endif() + set_property(GLOBAL APPEND PROPERTY MITK_EXTERNAL_PROJECTS ${EP_NAME}) + if(NOT EP_DOC) + set(EP_DOC "Use ${EP_NAME}") + endif() + if(NOT EP_PACKAGE AND NOT EP_NO_PACKAGE) + set(EP_PACKAGE ${EP_NAME}) + endif() + + set(_use_var "MITK_USE_${EP_NAME}") + set(_on 0) + if(EP_ON OR ${_use_var}) + set(_on 1) + endif() + + if(_on) + # Force dependencies to ON + foreach(dep ${EP_DEPENDS}) + if(NOT MITK_USE_${dep}) + get_property(_depends_doc CACHE MITK_USE_${dep} PROPERTY HELPSTRING) + get_property(_depends_type CACHE MITK_USE_${dep} PROPERTY TYPE) + if(NOT TYPE STREQUAL "INTERNAL") + # This is a cache UI variable + message("> Forcing MITK_USE_${dep} to ON because of ${_use_var}") + set(MITK_USE_${dep} ON CACHE BOOL "${_depends_doc}" FORCE) + else() + # This is an internal cache variable + set(MITK_USE_${dep} ON CACHE INTERNAL "${_depends_doc}" FORCE) + endif() + endif() + endforeach() + endif() + + # Set the actual MITK_USE_ cache variable + if(EP_NO_CACHE) + set(${_use_var} ${_on} CACHE INTERNAL "${EP_DOC}" FORCE) + else() + env_option(${_use_var} "${EP_DOC}" ${_on}) + #set(${_use_var} ${_on} CACHE BOOL "${EP_DOC}" FORCE) + if(EP_ADVANCED) + mark_as_advanced(${_use_var}) + endif() + endif() + set_property(GLOBAL PROPERTY MITK_${EP_NAME}_PACKAGE ${EP_PACKAGE}) + set_property(GLOBAL PROPERTY MITK_${EP_NAME}_COMPONENTS "${EP_COMPONENTS}") +endfunction() diff --git a/CMake/mitkMacroFindDependency.cmake b/CMake/mitkMacroFindDependency.cmake new file mode 100644 index 0000000000..96e9a408a5 --- /dev/null +++ b/CMake/mitkMacroFindDependency.cmake @@ -0,0 +1,55 @@ +#! Wraps a find_package call by forwarding QUIET and REQUIRED arguments +#! from within the MITKConfig.cmake file. +#! +#! mitkMacroFindDependency( [args]) +#! +macro(mitkMacroFindDependency dep) + + set(_mitk_fd_dep ${dep}) + if(NOT _mitk_fd_dep) + message(FATAL_ERROR "Missing argument.") + endif() + + string(TOUPPER "${_mitk_fd_dep}" _mitk_fd_dep_uc) + if (NOT (${_mitk_fd_dep}_FOUND OR ${_mitk_fd_dep_uc}_FOUND)) + if(${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY) + set(_mitk_fd_quiet_arg QUIET) + endif() + set(_mitk_fd_required_arg) + if(${CMAKE_FIND_PACKAGE_NAME}_FIND_REQUIRED) + set(_mitk_fd_required_arg REQUIRED) + endif() + + get_property(_mitk_fd_is_transitive GLOBAL PROPERTY + _CMAKE_${_mitk_fd_dep}_TRANSITIVE_DEPENDENCY + ) + + # Prefer config mode first because it finds external + # Config.cmake files pointed at by _DIR variables. + # Otherwise, existing Find.cmake files could file + # (e.g. in the case of GLEW and the FindGLEW.cmake file shipped + # with CMake). + find_package(${_mitk_fd_dep} ${ARGN} + QUIET + CONFIG + ) + if(NOT (${_mitk_fd_dep}_FOUND OR ${_mitk_fd_dep_uc}_FOUND)) + find_package(${_mitk_fd_dep} ${ARGN} + ${cmake_fd_quiet_arg} + ${cmake_fd_required_arg} + ) + endif() + + if(NOT DEFINED _mitk_fd_is_transitive OR _mitk_fd_is_transitive) + set_property(GLOBAL PROPERTY _CMAKE_${_mitk_fd_dep}_TRANSITIVE_DEPENDENCY TRUE) + endif() + + if (NOT (${_mitk_fd_dep}_FOUND OR ${_mitk_fd_dep_uc}_FOUND)) + set(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE "${CMAKE_FIND_PACKAGE_NAME} could not be found because dependency ${_mitk_fd_dep} could not be found.") + set(${CMAKE_FIND_PACKAGE_NAME}_FOUND False) + return() + endif() + set(_mitk_fd_required_arg) + set(_mitk_fd_quiet_arg) + endif() +endmacro() diff --git a/CMakeExternals/ANN.cmake b/CMakeExternals/ANN.cmake index 59bda81646..49b0ff6666 100644 --- a/CMakeExternals/ANN.cmake +++ b/CMakeExternals/ANN.cmake @@ -1,40 +1,40 @@ #----------------------------------------------------------------------------- # ANN #----------------------------------------------------------------------------- if(MITK_USE_ANN) # Sanity checks if(DEFINED ANN_DIR AND NOT EXISTS ${ANN_DIR}) message(FATAL_ERROR "ANN_DIR variable is defined but corresponds to non-existing directory") endif() set(proj ANN) set(proj_DEPENDENCIES ) set(ANN_DEPENDS ${proj}) if(NOT DEFINED ANN_DIR) set(patch_cmd ${CMAKE_COMMAND} -Dproj:STRING=${proj} -Dproj_target:STRING=ann -P ${CMAKE_CURRENT_LIST_DIR}/GenerateDefaultCMakeBuildSystem.cmake) ExternalProject_Add(${proj} LIST_SEPARATOR ${sep} URL ${MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL}/ann_1.1.2.tar.gz URL_MD5 7ffaacc7ea79ca39d4958a6378071365 PATCH_COMMAND ${patch_cmd} CMAKE_GENERATOR ${gen} CMAKE_ARGS ${ep_common_args} DEPENDS ${proj_DEPENDENCIES} ) - set(ANN_DIR ${ep_prefix}) + set(ANN_DIR ${ep_prefix}/lib/cmake/ANN) mitkFunctionInstallExternalCMakeProject(${proj}) else() mitkMacroEmptyExternalProject(${proj} "${proj_DEPENDENCIES}") endif() endif() diff --git a/CMakeExternals/CTK.cmake b/CMakeExternals/CTK.cmake index a4964b2015..09c7800734 100644 --- a/CMakeExternals/CTK.cmake +++ b/CMakeExternals/CTK.cmake @@ -1,114 +1,112 @@ #----------------------------------------------------------------------------- # CTK #----------------------------------------------------------------------------- if(MITK_USE_CTK) # Sanity checks if(DEFINED CTK_DIR AND NOT EXISTS ${CTK_DIR}) message(FATAL_ERROR "CTK_DIR variable is defined but corresponds to non-existing directory") endif() set(proj CTK) set(proj_DEPENDENCIES ) set(CTK_DEPENDS ${proj}) if(NOT DEFINED CTK_DIR) - set(revision_tag 8109d518) + set(revision_tag d8cd14e7) #IF(${proj}_REVISION_TAG) # SET(revision_tag ${${proj}_REVISION_TAG}) #ENDIF() set(ctk_optional_cache_args ) if(MITK_USE_Python) if(NOT MITK_USE_SYSTEM_PYTHON) list(APPEND proj_DEPENDENCIES Python) endif() list(APPEND ctk_optional_cache_args -DCTK_LIB_Scripting/Python/Widgets:BOOL=ON -DCTK_ENABLE_Python_Wrapping:BOOL=ON -DCTK_APP_ctkSimplePythonShell:BOOL=ON -DPYTHON_EXECUTABLE:FILEPATH=${PYTHON_EXECUTABLE} -DPYTHON_INCLUDE_DIR:PATH=${PYTHON_INCLUDE_DIR} -DPYTHON_INCLUDE_DIR2:PATH=${PYTHON_INCLUDE_DIR2} -DPYTHON_LIBRARY:FILEPATH=${PYTHON_LIBRARY} ) else() list(APPEND ctk_optional_cache_args -DCTK_LIB_Scripting/Python/Widgets:BOOL=OFF -DCTK_ENABLE_Python_Wrapping:BOOL=OFF -DCTK_APP_ctkSimplePythonShell:BOOL=OFF ) endif() if(MITK_USE_DCMTK) list(APPEND ctk_optional_cache_args -DDCMTK_DIR:PATH=${DCMTK_DIR} -DDCMTK_CMAKE_DEBUG_POSTFIX:STRING=d ) list(APPEND proj_DEPENDENCIES DCMTK) else() list(APPEND ctk_optional_cache_args -DDCMTK_URL:STRING=${MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL}/CTK_DCMTK_085525e6.tar.gz ) endif() set (ctk_qt_args -DCTK_QT_VERSION:STRING=${DESIRED_QT_VERSION}) if (DESIRED_QT_VERSION MATCHES "5") list(APPEND ctk_qt_args -DQT5_INSTALL_PREFIX:FILEPATH=${QT5_INSTALL_PREFIX}) else() list(APPEND ctk_qt_args -DQT_QMAKE_EXECUTABLE:FILEPATH=${QT_QMAKE_EXECUTABLE}) endif() FOREACH(type RUNTIME ARCHIVE LIBRARY) IF(DEFINED CTK_PLUGIN_${type}_OUTPUT_DIRECTORY) LIST(APPEND mitk_optional_cache_args -DCTK_PLUGIN_${type}_OUTPUT_DIRECTORY:PATH=${CTK_PLUGIN_${type}_OUTPUT_DIRECTORY}) ENDIF() ENDFOREACH() ExternalProject_Add(${proj} LIST_SEPARATOR ${sep} - GIT_REPOSITORY https://github.com/saschazelzer/CTK - GIT_TAG origin/improve-external-dependency-handling - #URL ${MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL}/CTK_${revision_tag}.tar.gz - #URL_MD5 a3ac62b6fdefc90966b52bc5b52c80e5 + URL ${MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL}/CTK_${revision_tag}.tar.gz + URL_MD5 2f1255494de6ae19aae3d4dc5f2ea6de UPDATE_COMMAND "" INSTALL_COMMAND "" CMAKE_GENERATOR ${gen} CMAKE_ARGS ${ep_common_args} ${ctk_optional_cache_args} ${ctk_qt_args} # The CTK PluginFramework cannot cope with # a non-empty CMAKE_DEBUG_POSTFIX for the plugin # libraries yet. -DCMAKE_DEBUG_POSTFIX:STRING= -DGit_EXECUTABLE:FILEPATH=${GIT_EXECUTABLE} -DGIT_EXECUTABLE:FILEPATH=${GIT_EXECUTABLE} -DCTK_LIB_CommandLineModules/Backend/LocalProcess:BOOL=ON -DCTK_LIB_CommandLineModules/Frontend/QtGui:BOOL=ON -DCTK_LIB_PluginFramework:BOOL=ON -DCTK_LIB_DICOM/Widgets:BOOL=ON -DCTK_LIB_XNAT/Core:BOOL=ON -DCTK_PLUGIN_org.commontk.eventadmin:BOOL=ON -DCTK_PLUGIN_org.commontk.configadmin:BOOL=ON -DCTK_USE_GIT_PROTOCOL:BOOL=OFF -DDCMTK_URL:STRING=${MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL}/CTK_DCMTK_085525e6.tar.gz -DqRestAPI_URL:STRING=${MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL}/qRestAPI_5f3a03b1.tar.gz DEPENDS ${proj_DEPENDENCIES} ) ExternalProject_Get_Property(${proj} binary_dir) set(CTK_DIR ${binary_dir}) #set(CTK_DIR ${ep_prefix}) #mitkFunctionInstallExternalCMakeProject(${proj}) else() mitkMacroEmptyExternalProject(${proj} "${proj_DEPENDENCIES}") endif() endif() diff --git a/CMakeExternals/CppUnit.cmake b/CMakeExternals/CppUnit.cmake index 14d24d134b..009ad6a164 100644 --- a/CMakeExternals/CppUnit.cmake +++ b/CMakeExternals/CppUnit.cmake @@ -1,37 +1,37 @@ #----------------------------------------------------------------------------- # CppUnit #----------------------------------------------------------------------------- # Sanity checks if(DEFINED CppUnit_DIR AND NOT EXISTS ${CppUnit_DIR}) message(FATAL_ERROR "CppUnit_DIR variable is defined but corresponds to non-existing directory") endif() set(proj CppUnit) set(proj_DEPENDENCIES ) set(${proj}_DEPENDS ${proj}) if(NOT DEFINED CppUnit_DIR) ExternalProject_Add(${proj} LIST_SEPARATOR ${sep} URL ${MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL}/cppunit-1.12.1.tar.gz URL_MD5 bd30e9cf5523cdfc019b94f5e1d7fd19 PATCH_COMMAND ${PATCH_COMMAND} -N -p1 -i ${CMAKE_CURRENT_LIST_DIR}/CppUnit-1.12.1.patch COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_LIST_DIR}/${proj}config.h.cmake /config/config.h.cmake COMMAND ${CMAKE_COMMAND} -Dproj=${proj} -Dproj_target:STRING=cppunit -P ${CMAKE_CURRENT_LIST_DIR}/GenerateDefaultCMakeBuildSystem.cmake CMAKE_GENERATOR ${gen} CMAKE_ARGS ${ep_common_args} DEPENDS ${proj_DEPENDENCIES} ) - set(${proj}_DIR ${ep_prefix}) + set(${proj}_DIR ${ep_prefix}/lib/cmake/CppUnit) mitkFunctionInstallExternalCMakeProject(${proj}) else() mitkMacroEmptyExternalProject(${proj} "${proj_DEPENDENCIES}") endif() diff --git a/CMakeExternals/Poco-1.6.0.patch b/CMakeExternals/Poco-1.6.0.patch index 0249c75b54..34017ad886 100644 --- a/CMakeExternals/Poco-1.6.0.patch +++ b/CMakeExternals/Poco-1.6.0.patch @@ -1,16 +1,152 @@ -diff -burN poco-1.6.0-all/CMakeLists.txt Poco-src/CMakeLists.txt +diff -urNb poco-1.6.0-all/cmake/PocoConfig.cmake.in Poco/cmake/PocoConfig.cmake.in +--- poco-1.6.0-all/cmake/PocoConfig.cmake.in 2014-12-22 09:04:42.000000000 +0100 ++++ Poco/cmake/PocoConfig.cmake.in 2015-02-04 04:12:45.464421452 +0100 +@@ -21,6 +21,10 @@ + + set(_Poco_NOTFOUND_MESSAGE) + ++# Let components find each other, but don't overwrite CMAKE_PREFIX_PATH ++set(_Poco_CMAKE_PREFIX_PATH_old ${CMAKE_PREFIX_PATH}) ++set(CMAKE_PREFIX_PATH ${_Poco_install_prefix}) ++ + foreach(module ${Poco_FIND_COMPONENTS}) + find_package(Poco${module} + ${_Poco_FIND_PARTS_QUIET} +@@ -39,6 +43,9 @@ + list(APPEND Poco_LIBRARIES "Poco::${module}") + endforeach() + ++# Restore the original CMAKE_PREFIX_PATH value ++set(CMAKE_PREFIX_PATH ${_Poco_CMAKE_PREFIX_PATH_old}) ++ + if (_Poco_NOTFOUND_MESSAGE) + set(Poco_NOT_FOUND_MESSAGE "${_Poco_NOTFOUND_MESSAGE}") + set(Poco_FOUND False) +diff -urNb poco-1.6.0-all/CMakeLists.txt Poco/CMakeLists.txt --- poco-1.6.0-all/CMakeLists.txt 2014-12-22 09:04:42.000000000 +0100 -+++ Poco-src/CMakeLists.txt 2015-01-12 15:29:30.230244365 +0100 ++++ Poco/CMakeLists.txt 2015-02-04 04:11:52.436420457 +0100 @@ -15,9 +15,9 @@ # Read the version information from the VERSION file file (STRINGS "${CMAKE_SOURCE_DIR}/VERSION" PACKAGE_VERSION ) message(STATUS "Poco package version: ${PACKAGE_VERSION}") -string(REGEX REPLACE "([0-9]+)\\.[0-9]+\\.[0-9]+" "\\1" CPACK_PACKAGE_VERSION_MAJOR ${PACKAGE_VERSION}) -string(REGEX REPLACE "[0-9]+\\.([0-9])+\\.[0-9]+" "\\1" CPACK_PACKAGE_VERSION_MINOR ${PACKAGE_VERSION}) -string(REGEX REPLACE "[0-9]+\\.[0-9]+\\.([0-9]+)" "\\1" CPACK_PACKAGE_VERSION_PATCH ${PACKAGE_VERSION}) +string(REGEX REPLACE "([0-9]+)\\.[0-9]+\\.[0-9]+.*" "\\1" CPACK_PACKAGE_VERSION_MAJOR ${PACKAGE_VERSION}) +string(REGEX REPLACE "[0-9]+\\.([0-9])+\\.[0-9]+.*" "\\1" CPACK_PACKAGE_VERSION_MINOR ${PACKAGE_VERSION}) +string(REGEX REPLACE "[0-9]+\\.[0-9]+\\.([0-9]+).*" "\\1" CPACK_PACKAGE_VERSION_PATCH ${PACKAGE_VERSION}) set(COMPLETE_VERSION ${CPACK_PACKAGE_VERSION_MAJOR}.${CPACK_PACKAGE_VERSION_MINOR}.${CPACK_PACKAGE_VERSION_PATCH}) set(RELEASE_NAME "Unstable-trunk") +diff -urNb poco-1.6.0-all/Crypto/cmake/PocoCryptoConfig.cmake Poco/Crypto/cmake/PocoCryptoConfig.cmake +--- poco-1.6.0-all/Crypto/cmake/PocoCryptoConfig.cmake 2014-12-22 09:04:51.000000000 +0100 ++++ Poco/Crypto/cmake/PocoCryptoConfig.cmake 2015-02-04 04:12:32.200421203 +0100 +@@ -1,4 +1,3 @@ + include(CMakeFindDependencyMacro) +-set(CMAKE_PREFIX_PATH ${CMAKE_CURRENT_LIST_DIR}) + find_dependency(PocoFoundation) + include("${CMAKE_CURRENT_LIST_DIR}/PocoCryptoTargets.cmake") +\ No newline at end of file +diff -urNb poco-1.6.0-all/Data/cmake/PocoDataConfig.cmake Poco/Data/cmake/PocoDataConfig.cmake +--- poco-1.6.0-all/Data/cmake/PocoDataConfig.cmake 2014-12-22 09:04:52.000000000 +0100 ++++ Poco/Data/cmake/PocoDataConfig.cmake 2015-02-04 04:12:32.208421203 +0100 +@@ -1,4 +1,3 @@ + include(CMakeFindDependencyMacro) +-set(CMAKE_PREFIX_PATH ${CMAKE_CURRENT_LIST_DIR}) + find_dependency(PocoFoundation) + include("${CMAKE_CURRENT_LIST_DIR}/PocoDataTargets.cmake") +\ No newline at end of file +diff -urNb poco-1.6.0-all/Data/MySQL/cmake/PocoDataMySQLConfig.cmake Poco/Data/MySQL/cmake/PocoDataMySQLConfig.cmake +--- poco-1.6.0-all/Data/MySQL/cmake/PocoDataMySQLConfig.cmake 2014-12-22 09:04:55.000000000 +0100 ++++ Poco/Data/MySQL/cmake/PocoDataMySQLConfig.cmake 2015-02-04 04:12:32.208421203 +0100 +@@ -1,5 +1,4 @@ + include(CMakeFindDependencyMacro) +-set(CMAKE_PREFIX_PATH ${CMAKE_CURRENT_LIST_DIR}) + find_dependency(PocoFoundation) + find_dependency(PocoData) + include("${CMAKE_CURRENT_LIST_DIR}/PocoDataMySQLTargets.cmake") +\ No newline at end of file +diff -urNb poco-1.6.0-all/Data/ODBC/cmake/PocoDataODBCConfig.cmake Poco/Data/ODBC/cmake/PocoDataODBCConfig.cmake +--- poco-1.6.0-all/Data/ODBC/cmake/PocoDataODBCConfig.cmake 2014-12-22 09:04:54.000000000 +0100 ++++ Poco/Data/ODBC/cmake/PocoDataODBCConfig.cmake 2015-02-04 04:12:32.208421203 +0100 +@@ -1,5 +1,4 @@ + include(CMakeFindDependencyMacro) +-set(CMAKE_PREFIX_PATH ${CMAKE_CURRENT_LIST_DIR}) + find_dependency(PocoFoundation) + find_dependency(PocoData) + include("${CMAKE_CURRENT_LIST_DIR}/PocoDataODBCTargets.cmake") +\ No newline at end of file +diff -urNb poco-1.6.0-all/Data/SQLite/cmake/PocoDataSQLiteConfig.cmake Poco/Data/SQLite/cmake/PocoDataSQLiteConfig.cmake +--- poco-1.6.0-all/Data/SQLite/cmake/PocoDataSQLiteConfig.cmake 2014-12-22 09:04:54.000000000 +0100 ++++ Poco/Data/SQLite/cmake/PocoDataSQLiteConfig.cmake 2015-02-04 04:12:32.208421203 +0100 +@@ -1,5 +1,4 @@ + include(CMakeFindDependencyMacro) +-set(CMAKE_PREFIX_PATH ${CMAKE_CURRENT_LIST_DIR}) + find_dependency(PocoFoundation) + find_dependency(PocoData) + include("${CMAKE_CURRENT_LIST_DIR}/PocoDataSQLiteTargets.cmake") +\ No newline at end of file +diff -urNb poco-1.6.0-all/JSON/cmake/PocoJSONConfig.cmake Poco/JSON/cmake/PocoJSONConfig.cmake +--- poco-1.6.0-all/JSON/cmake/PocoJSONConfig.cmake 2014-12-22 09:04:48.000000000 +0100 ++++ Poco/JSON/cmake/PocoJSONConfig.cmake 2015-02-04 04:12:32.208421203 +0100 +@@ -1,4 +1,3 @@ + include(CMakeFindDependencyMacro) +-set(CMAKE_PREFIX_PATH ${CMAKE_CURRENT_LIST_DIR}) + find_dependency(PocoFoundation) + include("${CMAKE_CURRENT_LIST_DIR}/PocoJSONTargets.cmake") +\ No newline at end of file +diff -urNb poco-1.6.0-all/MongoDB/cmake/PocoMongoDBConfig.cmake Poco/MongoDB/cmake/PocoMongoDBConfig.cmake +--- poco-1.6.0-all/MongoDB/cmake/PocoMongoDBConfig.cmake 2014-12-22 09:04:55.000000000 +0100 ++++ Poco/MongoDB/cmake/PocoMongoDBConfig.cmake 2015-02-04 04:12:32.208421203 +0100 +@@ -1,5 +1,4 @@ + include(CMakeFindDependencyMacro) +-set(CMAKE_PREFIX_PATH ${CMAKE_CURRENT_LIST_DIR}) + find_dependency(PocoFoundation) + find_dependency(PocoNet) + include("${CMAKE_CURRENT_LIST_DIR}/PocoMongoDBTargets.cmake") +\ No newline at end of file +diff -urNb poco-1.6.0-all/Net/cmake/PocoNetConfig.cmake Poco/Net/cmake/PocoNetConfig.cmake +--- poco-1.6.0-all/Net/cmake/PocoNetConfig.cmake 2014-12-22 09:04:50.000000000 +0100 ++++ Poco/Net/cmake/PocoNetConfig.cmake 2015-02-04 04:12:32.208421203 +0100 +@@ -1,4 +1,3 @@ + include(CMakeFindDependencyMacro) +-set(CMAKE_PREFIX_PATH ${CMAKE_CURRENT_LIST_DIR}) + find_dependency(PocoFoundation) + include("${CMAKE_CURRENT_LIST_DIR}/PocoNetTargets.cmake") +\ No newline at end of file +diff -urNb poco-1.6.0-all/NetSSL_OpenSSL/cmake/PocoNetSSLConfig.cmake Poco/NetSSL_OpenSSL/cmake/PocoNetSSLConfig.cmake +--- poco-1.6.0-all/NetSSL_OpenSSL/cmake/PocoNetSSLConfig.cmake 2014-12-22 09:04:52.000000000 +0100 ++++ Poco/NetSSL_OpenSSL/cmake/PocoNetSSLConfig.cmake 2015-02-04 04:12:32.208421203 +0100 +@@ -1,5 +1,4 @@ + include(CMakeFindDependencyMacro) +-set(CMAKE_PREFIX_PATH ${CMAKE_CURRENT_LIST_DIR}) + find_dependency(PocoFoundation) + find_dependency(PocoUtil) + find_dependency(PocoNet) +diff -urNb poco-1.6.0-all/Util/cmake/PocoUtilConfig.cmake Poco/Util/cmake/PocoUtilConfig.cmake +--- poco-1.6.0-all/Util/cmake/PocoUtilConfig.cmake 2014-12-22 09:04:49.000000000 +0100 ++++ Poco/Util/cmake/PocoUtilConfig.cmake 2015-02-04 04:12:45.464421452 +0100 +@@ -1,5 +1,4 @@ + include(CMakeFindDependencyMacro) +-set(CMAKE_PREFIX_PATH ${CMAKE_CURRENT_LIST_DIR}) + find_dependency(PocoFoundation) + find_dependency(PocoXML) + find_dependency(PocoJSON) +diff -urNb poco-1.6.0-all/XML/cmake/PocoXMLConfig.cmake Poco/XML/cmake/PocoXMLConfig.cmake +--- poco-1.6.0-all/XML/cmake/PocoXMLConfig.cmake 2014-12-22 09:04:47.000000000 +0100 ++++ Poco/XML/cmake/PocoXMLConfig.cmake 2015-02-04 04:12:45.464421452 +0100 +@@ -1,4 +1,3 @@ + include(CMakeFindDependencyMacro) +-set(CMAKE_PREFIX_PATH ${CMAKE_CURRENT_LIST_DIR}) + find_dependency(PocoFoundation) + include("${CMAKE_CURRENT_LIST_DIR}/PocoXMLTargets.cmake") +\ No newline at end of file +diff -urNb poco-1.6.0-all/Zip/cmake/PocoZipConfig.cmake Poco/Zip/cmake/PocoZipConfig.cmake +--- poco-1.6.0-all/Zip/cmake/PocoZipConfig.cmake 2014-12-22 09:04:55.000000000 +0100 ++++ Poco/Zip/cmake/PocoZipConfig.cmake 2015-02-04 04:12:45.464421452 +0100 +@@ -1,5 +1,4 @@ + include(CMakeFindDependencyMacro) +-set(CMAKE_PREFIX_PATH ${CMAKE_CURRENT_LIST_DIR}) + find_dependency(PocoFoundation) + find_dependency(PocoUtil) + find_dependency(PocoXML) diff --git a/CMakeExternals/raptor2-2.0.15.patch b/CMakeExternals/Raptor2-2.0.15.patch similarity index 100% rename from CMakeExternals/raptor2-2.0.15.patch rename to CMakeExternals/Raptor2-2.0.15.patch diff --git a/CMakeExternals/raptor2.cmake b/CMakeExternals/Raptor2.cmake similarity index 86% rename from CMakeExternals/raptor2.cmake rename to CMakeExternals/Raptor2.cmake index 9967b632a5..3d25abb54a 100644 --- a/CMakeExternals/raptor2.cmake +++ b/CMakeExternals/Raptor2.cmake @@ -1,60 +1,60 @@ #----------------------------------------------------------------------------- # raptor2 #----------------------------------------------------------------------------- -if(MITK_USE_raptor2) +if(MITK_USE_Raptor2) # Sanity checks -if(DEFINED raptor2_DIR AND NOT EXISTS ${raptor2_DIR}) - message(FATAL_ERROR "raptor2_DIR variable is defined but corresponds to non-existing directory") +if(DEFINED Raptor2_DIR AND NOT EXISTS ${Raptor2_DIR}) + message(FATAL_ERROR "Raptor2_DIR variable is defined but corresponds to non-existing directory") endif() -set(proj raptor2) +set(proj Raptor2) set(proj_DEPENDENCIES ) set(${proj}_DEPENDS ${proj}) -if(NOT DEFINED raptor2_DIR) +if(NOT DEFINED Raptor2_DIR) ExternalProject_Add(${proj} LIST_SEPARATOR ${sep} URL ${MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL}/raptor2-2.0.15.tar.gz URL_MD5 a39f6c07ddb20d7dd2ff1f95fa21e2cd - PATCH_COMMAND ${PATCH_COMMAND} -N -p1 -i ${CMAKE_CURRENT_LIST_DIR}/raptor2-2.0.15.patch + PATCH_COMMAND ${PATCH_COMMAND} -N -p1 -i ${CMAKE_CURRENT_LIST_DIR}/Raptor2-2.0.15.patch CMAKE_GENERATOR ${gen} CMAKE_ARGS ${ep_common_args} -DRAPTOR_ENABLE_TESTING:BOOL=OFF -DRAPTOR_PARSER_GRDDL:BOOL=OFF -DRAPTOR_PARSER_GUESS:BOOL=OFF -DRAPTOR_PARSER_JSON:BOOL=OFF -DRAPTOR_PARSER_NQUADS:BOOL=ON -DRAPTOR_PARSER_NTRIPLES:BOOL=ON -DRAPTOR_PARSER_RDFA:BOOL=OFF -DRAPTOR_PARSER_RDFXML:BOOL=OFF -DRAPTOR_PARSER_RSS:BOOL=OFF -DRAPTOR_PARSER_TRIG:BOOL=OFF -DRAPTOR_PARSER_TURTLE:BOOL=ON -DRAPTOR_SERIALIZER_ATOM:BOOL=OFF -DRAPTOR_SERIALIZER_DOT:BOOL=OFF -DRAPTOR_SERIALIZER_HTML:BOOL=OFF -DRAPTOR_SERIALIZER_JSON:BOOL=OFF -DRAPTOR_SERIALIZER_NQUADS:BOOL=ON -DRAPTOR_SERIALIZER_NTRIPLES:BOOL=ON -DRAPTOR_SERIALIZER_RDFXML:BOOL=OFF -DRAPTOR_SERIALIZER_RDFXML_ABBREV:BOOL=OFF -DRAPTOR_SERIALIZER_RSS_1_0:BOOL=OFF -DRAPTOR_SERIALIZER_TURTLE:BOOL=ON -DCMAKE_INSTALL_NAME_DIR:STRING=${REDLAND_INSTALL_DIR}/lib DEPENDS ${proj_DEPENDENCIES} ) - set(${proj}_DIR ${ep_prefix}) + set(${proj}_DIR ${ep_prefix}/lib/raptor2/cmake) mitkFunctionInstallExternalCMakeProject(${proj}) else() mitkMacroEmptyExternalProject(${proj} "${proj_DEPENDENCIES}") endif() endif() diff --git a/CMakeExternals/rasqal-0.9.32.patch b/CMakeExternals/Rasqal-0.9.32.patch similarity index 100% rename from CMakeExternals/rasqal-0.9.32.patch rename to CMakeExternals/Rasqal-0.9.32.patch diff --git a/CMakeExternals/rasqal.cmake b/CMakeExternals/Rasqal.cmake similarity index 76% rename from CMakeExternals/rasqal.cmake rename to CMakeExternals/Rasqal.cmake index 1613f0a87a..965caaadde 100644 --- a/CMakeExternals/rasqal.cmake +++ b/CMakeExternals/Rasqal.cmake @@ -1,44 +1,44 @@ #----------------------------------------------------------------------------- # rasqal #----------------------------------------------------------------------------- -if(MITK_USE_rasqal) +if(MITK_USE_Rasqal) # Sanity checks -if(DEFINED rasqal_DIR AND NOT EXISTS ${rasqal_DIR}) - message(FATAL_ERROR "rasqal_DIR variable is defined but corresponds to non-existing directory") +if(DEFINED Rasqal_DIR AND NOT EXISTS ${Rasqal_DIR}) + message(FATAL_ERROR "Rasqal_DIR variable is defined but corresponds to non-existing directory") endif() -set(proj rasqal) -set(proj_DEPENDENCIES ${raptor2_DEPENDS} ${PCRE_DEPENDS}) +set(proj Rasqal) +set(proj_DEPENDENCIES ${Raptor2_DEPENDS} ${PCRE_DEPENDS}) set(${proj}_DEPENDS ${proj}) -if(NOT DEFINED rasqal_DIR) +if(NOT DEFINED Rasqal_DIR) ExternalProject_Add(${proj} LIST_SEPARATOR ${sep} URL ${MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL}/rasqal-0.9.32.tar.gz URL_MD5 dc7c6107de00c47f85f6ab7db164a136 - PATCH_COMMAND ${PATCH_COMMAND} -N -p1 -i ${CMAKE_CURRENT_LIST_DIR}/rasqal-0.9.32.patch + PATCH_COMMAND ${PATCH_COMMAND} -N -p1 -i ${CMAKE_CURRENT_LIST_DIR}/Rasqal-0.9.32.patch LIST_SEPARATOR ^^ CMAKE_GENERATOR ${gen} CMAKE_ARGS ${ep_common_args} "-DCMAKE_C_FLAGS:STRING=-DPCRE_STATIC ${CMAKE_C_FLAGS}" -DRASQAL_REGEX:STRING=pcre -DCMAKE_PREFIX_PATH:STRING=${PCRE_DIR}^^${REDLAND_INSTALL_DIR} -DPCRE_INCLUDE_DIR:PATH=${PCRE_DIR}/include -DCMAKE_INSTALL_NAME_DIR:STRING=${REDLAND_INSTALL_DIR}/lib DEPENDS ${proj_DEPENDENCIES} ) - set(${proj}_DIR ${ep_prefix}) + set(${proj}_DIR ${ep_prefix}/lib/rasqal/cmake) mitkFunctionInstallExternalCMakeProject(${proj}) else() mitkMacroEmptyExternalProject(${proj} "${proj_DEPENDENCIES}") endif() endif() diff --git a/CMakeExternals/redland-1.0.17.patch b/CMakeExternals/Redland-1.0.17.patch similarity index 100% rename from CMakeExternals/redland-1.0.17.patch rename to CMakeExternals/Redland-1.0.17.patch diff --git a/CMakeExternals/redland.cmake b/CMakeExternals/Redland.cmake similarity index 70% rename from CMakeExternals/redland.cmake rename to CMakeExternals/Redland.cmake index 24877b6aad..b156f51fb6 100644 --- a/CMakeExternals/redland.cmake +++ b/CMakeExternals/Redland.cmake @@ -1,39 +1,39 @@ #----------------------------------------------------------------------------- # redland #----------------------------------------------------------------------------- -if(MITK_USE_redland) +if(MITK_USE_Redland) # Sanity checks -if(DEFINED redland_DIR AND NOT EXISTS ${redland_DIR}) - message(FATAL_ERROR "redland_DIR variable is defined but corresponds to non-existing directory") +if(DEFINED Redland_DIR AND NOT EXISTS ${Redland_DIR}) + message(FATAL_ERROR "Redland_DIR variable is defined but corresponds to non-existing directory") endif() -set(proj redland) -set(proj_DEPENDENCIES ${raptor2_DEPENDS} ${rasqal_DEPENDS}) +set(proj Redland) +set(proj_DEPENDENCIES ${Raptor2_DEPENDS} ${Rasqal_DEPENDS}) set(${proj}_DEPENDS ${proj}) -if(NOT DEFINED redland_DIR) +if(NOT DEFINED Redland_DIR) ExternalProject_Add(${proj} LIST_SEPARATOR ${sep} URL ${MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL}/redland-1.0.17.tar.gz URL_MD5 e5be03eda13ef68aabab6e42aa67715e - PATCH_COMMAND ${PATCH_COMMAND} -N -p1 -i ${CMAKE_CURRENT_LIST_DIR}/redland-1.0.17.patch + PATCH_COMMAND ${PATCH_COMMAND} -N -p1 -i ${CMAKE_CURRENT_LIST_DIR}/Redland-1.0.17.patch CMAKE_GENERATOR ${gen} CMAKE_ARGS ${ep_common_args} -DWITH_THREADS:BOOL=OFF DEPENDS ${proj_DEPENDENCIES} ) - set(${proj}_DIR ${ep_prefix}) + set(${proj}_DIR ${ep_prefix}/lib/redland/cmake) mitkFunctionInstallExternalCMakeProject(${proj}) else() mitkMacroEmptyExternalProject(${proj} "${proj_DEPENDENCIES}") endif() endif() diff --git a/CMakeExternals/Swig.cmake b/CMakeExternals/SWIG.cmake similarity index 88% rename from CMakeExternals/Swig.cmake rename to CMakeExternals/SWIG.cmake index 7d2277f506..1137a6bb72 100644 --- a/CMakeExternals/Swig.cmake +++ b/CMakeExternals/SWIG.cmake @@ -1,69 +1,69 @@ #------------------------------------------------------------ # SWIG (Simple Wrapper Interface Generator) #----------------------------------------------------------- if(MITK_USE_SWIG) - if(DEFINED Swig_DIR AND NOT EXISTS ${Swig_DIR}) - message(FATAL_ERROR "Swig_DIR variable is defined but corresponds to non-existing directory") + if(DEFINED SWIG_DIR AND NOT EXISTS ${SWIG_DIR}) + message(FATAL_ERROR "SWIG_DIR variable is defined but corresponds to non-existing directory") endif() if(NOT SWIG_DIR) # We don't "install" SWIG in the common install prefix, # since it is only used as a tool during the MITK super-build # to generate the Python wrappings for some projects. set(SWIG_TARGET_VERSION 3.0.2) - set(proj Swig) - set(Swig_DEPENDENCIES PCRE) - set(Swig_DEPENDS ${proj}) + set(proj SWIG) + set(SWIG_DEPENDENCIES PCRE) + set(SWIG_DEPENDS ${proj}) # binary SWIG for windows if(WIN32) set(swig_source_dir ${CMAKE_CURRENT_BINARY_DIR}/swigwin-${SWIG_TARGET_VERSION}) # swig.exe available as pre-built binary on Windows: ExternalProject_Add(${proj} URL ${MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL}/swigwin-${SWIG_TARGET_VERSION}.zip URL_MD5 "3f18de4fc09ab9abb0d3be37c11fbc8f" CONFIGURE_COMMAND "" BUILD_COMMAND "" INSTALL_COMMAND "" ) ExternalProject_Get_Property(${proj} source_dir) set(SWIG_DIR ${source_dir}) set(SWIG_EXECUTABLE ${source_dir}/swig.exe) else() - list(APPEND Swig_DEPENDENCIES PCRE) + list(APPEND SWIG_DEPENDENCIES PCRE) # swig uses bison find it by cmake and pass it down find_package(BISON) set(BISON_FLAGS "" CACHE STRING "Flags used by bison") mark_as_advanced( BISON_FLAGS) ExternalProject_add(${proj} LIST_SEPARATOR ${sep} URL ${MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL}/swig-${SWIG_TARGET_VERSION}.tar.gz # Custom install dir for SWIG INSTALL_DIR ${ep_prefix}/src/${proj}-install URL_MD5 "62f9b0d010cef36a13a010dc530d0d41" CONFIGURE_COMMAND /./configure CC=${CMAKE_C_COMPILER}${CMAKE_C_COMPILER_ARG1} LDFLAGS=${CMAKE_LINKER_FLAGS} ${CMAKE_LINKER_FLAGS_RELEASE} CXX=${CMAKE_CXX_COMPILER}${CMAKE_CXX_COMPILER_ARG1} --prefix= --with-pcre-prefix=${PCRE_DIR} --without-octave --with-python=${PYTHON_EXECUTABLE} - DEPENDS ${Swig_DEPENDENCIES} + DEPENDS ${SWIG_DEPENDENCIES} ) ExternalProject_Get_Property(${proj} install_dir) set(SWIG_DIR ${install_dir}/share/swig/${SWIG_TARGET_VERSION}) set(SWIG_EXECUTABLE ${install_dir}/bin/swig) endif() - endif(NOT SWIG_DIR) + endif() endif() diff --git a/CMakeExternals/SimpleITK.cmake b/CMakeExternals/SimpleITK.cmake index f93462a23a..c04f0d876c 100644 --- a/CMakeExternals/SimpleITK.cmake +++ b/CMakeExternals/SimpleITK.cmake @@ -1,126 +1,126 @@ #----------------------------------------------------------------------------- # SimpleITK #----------------------------------------------------------------------------- if(MITK_USE_SimpleITK) # Sanity checks if(DEFINED SimpleITK_DIR AND NOT EXISTS ${SimpleITK_DIR}) message(FATAL_ERROR "SimpleITK_DIR variable is defined but corresponds to non-existing directory") endif() set(proj SimpleITK) - set(proj_DEPENDENCIES ITK GDCM Swig) + set(proj_DEPENDENCIES ITK GDCM SWIG) if(MITK_USE_OpenCV) list(APPEND proj_DEPENDENCIES OpenCV) endif() set(SimpleITK_DEPENDS ${proj}) if(NOT DEFINED SimpleITK_DIR) set(additional_cmake_args ) list(APPEND additional_cmake_args -DWRAP_CSHARP:BOOL=OFF -DWRAP_TCL:BOOL=OFF -DWRAP_LUA:BOOL=OFF -DWRAP_PYTHON:BOOL=OFF -DWRAP_JAVA:BOOL=OFF -DWRAP_RUBY:BOOL=OFF -DWRAP_R:BOOL=OFF ) if(MITK_USE_Python) list(APPEND additional_cmake_args -DWRAP_PYTHON:BOOL=ON -DPYTHON_EXECUTABLE:FILEPATH=${PYTHON_EXECUTABLE} -DPYTHON_INCLUDE_DIR:PATH=${PYTHON_INCLUDE_DIR} -DPYTHON_INCLUDE_DIR2:PATH=${PYTHON_INCLUDE_DIR2} -DPYTHON_LIBRARY:FILEPATH=${PYTHON_LIBRARY} ) if(NOT MITK_USE_SYSTEM_PYTHON) list(APPEND proj_DEPENDENCIES Python) endif() endif() #TODO: Installer and testing works only with static libs on MAC set(_build_shared ON) if(APPLE) set(_build_shared OFF) endif() ExternalProject_Add(${proj} LIST_SEPARATOR ${sep} URL ${MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL}/SimpleITK-0.8.1.tar.gz URL_MD5 9126ab2eda9e88f598a962c02a705c43 PATCH_COMMAND ${PATCH_COMMAND} -N -p1 -i ${CMAKE_CURRENT_LIST_DIR}/SimpleITK-0.8.1.patch CMAKE_ARGS ${ep_common_args} # -DCMAKE_BUILD_WITH_INSTALL_RPATH:BOOL=ON CMAKE_CACHE_ARGS ${additional_cmake_args} -DBUILD_SHARED_LIBS:BOOL=${_build_shared} -DSimpleITK_BUILD_DISTRIBUTE:BOOL=ON -DSimpleITK_PYTHON_THREADS:BOOL=ON -DUSE_SYSTEM_ITK:BOOL=ON -DBUILD_EXAMPLES:BOOL=OFF -DGDCM_DIR:PATH=${GDCM_DIR} -DITK_DIR:PATH=${ITK_DIR} -DSWIG_DIR:PATH=${SWIG_DIR} -DSWIG_EXECUTABLE:FILEPATH=${SWIG_EXECUTABLE} DEPENDS ${proj_DEPENDENCIES} ) set(SimpleITK_DIR ${ep_prefix}) if( MITK_USE_Python AND NOT MITK_USE_SYSTEM_PYTHON ) # PythonDir needs to be fixed for the python interpreter by # changing dir delimiter for Windows set(_install_dir ${Python_DIR}) if(WIN32) STRING(REPLACE "/" "\\\\" _install_dir ${Python_DIR}) else() # escape spaces in the install path for linux STRING(REPLACE " " "\ " _install_dir ${Python_DIR}) endif() # Build python distribution with easy install. If a own runtime is used # embedd the egg into the site-package folder of the runtime if(NOT MITK_USE_SYSTEM_PYTHON) ExternalProject_Add_Step(${proj} sitk_python_install_step COMMAND ${PYTHON_EXECUTABLE} setup.py install --prefix=${_install_dir} DEPENDEES build WORKING_DIRECTORY /Wrapping/PythonPackage ) # Build egg into custom user base folder and deploy it later into installer # https://pythonhosted.org/setuptools/easy_install.html#use-the-user-option-and-customize-pythonuserbase else() set(_userbase_install /Wrapping/PythonPackage/lib/python${PYTHON_VERSION_MAJOR}.${PYTHON_VERSION_MINOR}/site-packages) if(WIN32) set(_userbase_install /Wrapping/PythonPackage/Lib/site-packages) endif() ExternalProject_Add_Step(${proj} sitk_create_userbase_step COMMAND ${CMAKE_COMMAND} -E make_directory ${_userbase_install} DEPENDEES build WORKING_DIRECTORY ${SimpleITK_DIR}/Wrapping/PythonPackage ) ExternalProject_Add_Step(${proj} sitk_python_install_step COMMAND PYTHONUSERBASE=/Wrapping/PythonPackage ${PYTHON_EXECUTABLE} setup.py install --user DEPENDEES sitk_create_userbase_step WORKING_DIRECTORY /Wrapping/PythonPackage ) endif() endif() mitkFunctionInstallExternalCMakeProject(${proj}) # Still need to install the SimpleITK Python wrappings else() mitkMacroEmptyExternalProject(${proj} "${proj_DEPENDENCIES}") endif() endif() diff --git a/CMakeLists.txt b/CMakeLists.txt index aadf02f828..8831d14ec1 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,1149 +1,1266 @@ set(MITK_CMAKE_MINIMUM_REQUIRED_VERSION 3.1) cmake_minimum_required(VERSION ${MITK_CMAKE_MINIMUM_REQUIRED_VERSION}) #----------------------------------------------------------------------------- # Set a default build type if none was specified #----------------------------------------------------------------------------- if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES) message(STATUS "Setting build type to 'Debug' as none was specified.") set(CMAKE_BUILD_TYPE Debug CACHE STRING "Choose the type of build." FORCE) # Set the possible values of build type for cmake-gui set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS "Debug" "Release" "MinSizeRel" "RelWithDebInfo") endif() #----------------------------------------------------------------------------- # 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 VERSION 2014.10.99) endif() #----------------------------------------------------------------------------- # Check miminum compiler versions #----------------------------------------------------------------------------- if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU") # require at least gcc 4.6 as provided by Ubuntu 12.04 if (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.6) message(FATAL_ERROR "GCC version must be at least 4.6") endif() elseif("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang") # require at least clang 3.2 for correct RTTI handling and C++11 support if (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 3.2) message(FATAL_ERROR "Clang version must be at least 3.2") endif() elseif("${CMAKE_CXX_COMPILER_ID}" STREQUAL "AppleClang") # require at least clang 5.0 if (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 5.0) message(FATAL_ERROR "Apple Clang version must be at least 5.0") endif() elseif("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC") # require at least Visual Studio 2010 (msvc ...) if (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 16) message(FATAL_ERROR "Micorsoft Visual Studio 2010 or newer required (MSVC 16.0)") endif() else() message(WARNING "You are using an unsupported compiler! Compilation has only been tested with Clang (Linux or Apple), GCC and MSVC.") endif() #----------------------------------------------------------------------------- # Warn if source or build path is too long #----------------------------------------------------------------------------- if(WIN32) set(_src_dir_length_max 50) set(_bin_dir_length_max 50) if(MITK_USE_SUPERBUILD) set(_src_dir_length_max 43) # _src_dir_length_max - strlen(ITK-src) set(_bin_dir_length_max 40) # _bin_dir_length_max - strlen(MITK-build) endif() string(LENGTH "${MITK_SOURCE_DIR}" _src_n) string(LENGTH "${MITK_BINARY_DIR}" _bin_n) # The warnings should be converted to errors if(_src_n GREATER _src_dir_length_max) message(WARNING "MITK source code directory path length is too long (${_src_n} > ${_src_dir_length_max})." "Please move the MITK source code directory to a directory with a shorter path." ) endif() if(_bin_n GREATER _bin_dir_length_max) message(WARNING "MITK build directory path length is too long (${_bin_n} > ${_bin_dir_length_max})." "Please move the MITK build directory to a directory with a shorter path." ) endif() endif() #----------------------------------------------------------------------------- # See http://cmake.org/cmake/help/cmake-2-8-docs.html#section_Policies for details #----------------------------------------------------------------------------- set(project_policies ) foreach(policy ${project_policies}) if(POLICY ${policy}) cmake_policy(SET ${policy} NEW) endif() endforeach() #----------------------------------------------------------------------------- # Update CMake module path #------------------------------------------------------------------------------ set(MITK_CMAKE_DIR ${MITK_SOURCE_DIR}/CMake) set(CMAKE_MODULE_PATH ${MITK_CMAKE_DIR} ${CMAKE_MODULE_PATH} ) #----------------------------------------------------------------------------- # CMake function(s) and macro(s) #----------------------------------------------------------------------------- +# Standard CMake macros +include(FeatureSummary) +include(CTestUseLaunchers) +include(CMakeParseArguments) +include(FindPackageHandleStandardArgs) + +# MITK macros include(mitkMacroEmptyExternalProject) include(mitkFunctionGenerateProjectXml) include(mitkFunctionSuppressWarnings) include(mitkFunctionEnableBuildConfiguration) include(mitkFunctionWhitelists) -include(FeatureSummary) -include(CTestUseLaunchers) +include(mitkFunctionAddExternalProject) SUPPRESS_VC_DEPRECATED_WARNINGS() #----------------------------------------------------------------------------- # 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) - macro(env_option name doc value) set(_value $ENV{${name}}) if("${_value}" STREQUAL "") set(_value ${value}) endif() option(${name} "${doc}" ${_value}) endmacro() +# ----------------------------------------- +# General build options +option(BUILD_SHARED_LIBS "Build MITK with shared libraries" ON) +option(WITH_COVERAGE "Enable/Disable coverage" OFF) +option(BUILD_TESTING "Test the project" ON) + +env_option(MITK_BUILD_ALL_APPS "Build all MITK applications" OFF) +env_option(MITK_BUILD_EXAMPLES "Build the MITK Examples" OFF) +option(MITK_ENABLE_PIC_READER "Enable support for reading the DKFZ pic file format." ON) + +mark_as_advanced(MITK_BUILD_ALL_APPS + MITK_ENABLE_PIC_READER + ) + # ----------------------------------------- # Qt version related variables set(DESIRED_QT_VERSION 4 CACHE STRING "Pick a version of Qt to use: 4 or 5") env_option(MITK_USE_QT "Use Nokia's Qt library" ON) set(MITK_DESIRED_QT_VERSION ${DESIRED_QT_VERSION}) if(MITK_USE_QT) # find the package at the very beginning, so that QT4_FOUND is available if(DESIRED_QT_VERSION MATCHES 4) set(MITK_QT4_MINIMUM_VERSION 4.7) find_package(Qt4 ${MITK_QT4_MINIMUM_VERSION} REQUIRED) set(MITK_USE_Qt4 TRUE) set(MITK_USE_Qt5 FALSE) endif() if(DESIRED_QT_VERSION MATCHES 5) set(MITK_QT5_MINIMUM_VERSION 5.0.0) set(MITK_USE_Qt4 FALSE) set(MITK_USE_Qt5 TRUE) set(QT5_INSTALL_PREFIX "" CACHE PATH "The install location of Qt5") set(CMAKE_PREFIX_PATH ${CMAKE_PREFIX_PATH} ${QT5_INSTALL_PREFIX}) - find_package(Qt5Core ${MITK_QT5_MINIMUM_VERSION} REQUIRED) - find_package(Qt5Concurrent ${MITK_QT5_MINIMUM_VERSION} REQUIRED) - find_package(Qt5OpenGL ${MITK_QT5_MINIMUM_VERSION} REQUIRED) - find_package(Qt5PrintSupport ${MITK_QT5_MINIMUM_VERSION} REQUIRED) - find_package(Qt5Script ${MITK_QT5_MINIMUM_VERSION} REQUIRED) - find_package(Qt5Sql ${MITK_QT5_MINIMUM_VERSION} REQUIRED) - find_package(Qt5Svg ${MITK_QT5_MINIMUM_VERSION} REQUIRED) - find_package(Qt5WebKit ${MITK_QT5_MINIMUM_VERSION} REQUIRED) - find_package(Qt5WebKitWidgets ${MITK_QT5_MINIMUM_VERSION} REQUIRED) - find_package(Qt5Widgets ${MITK_QT5_MINIMUM_VERSION} REQUIRED) - find_package(Qt5Xml ${MITK_QT5_MINIMUM_VERSION} REQUIRED) - find_package(Qt5XmlPatterns ${MITK_QT5_MINIMUM_VERSION} REQUIRED) - find_package(Qt5UiTools ${MITK_QT5_MINIMUM_VERSION} REQUIRED) + set(MITK_QT5_COMPONENTS Concurrent OpenGL PrintSupport Script Sql Svg WebKitWidgets Xml XmlPatterns UiTools) + find_package(Qt5 ${MITK_QT5_MINIMUM_VERSION} COMPONENTS ${MITK_QT5_COMPONENTS} REQUIRED) endif() else() set(MITK_USE_Qt4 FALSE) set(MITK_USE_Qt5 FALSE) endif() +# ------------------------------------------------------------------------ +# Register external projects which can be build with the MITK superbuild +# system. Each mitkFunctionAddExternalProject() call registers an external +# project for which a CMakeExternals/.cmake file must exist. The +# call also creates a MITK_USE_ variable (appearing in the CMake +# UI if the NO_CACHE option is *not* given). + + # ----------------------------------------- -# MITK_USE_* build variables +# Optional external projects with no +# inter-dependencies -env_option(MITK_BUILD_ALL_APPS "Build all MITK applications" OFF) -set(MITK_BUILD_TUTORIAL OFF CACHE INTERNAL "Deprecated! Use MITK_BUILD_EXAMPLES instead!") -env_option(MITK_BUILD_EXAMPLES "Build the MITK Examples" ${MITK_BUILD_TUTORIAL}) -env_option(MITK_USE_ACVD "Use Approximated Centroidal Voronoi Diagrams" OFF) -env_option(MITK_USE_ANN "Use Approximate Nearest Neighbor Library" ON) -env_option(MITK_USE_CppUnit "Use CppUnit for unit tests" ON) -if(BUILD_TESTING AND NOT MITK_USE_CppUnit) - message("> Forcing MITK_USE_CppUnit to ON because BUILD_TESTING=ON") - set(MITK_USE_CppUnit ON CACHE BOOL "Use CppUnit for unit tests" FORCE) -endif() -env_option(MITK_USE_Eigen "Use the Eigen library" ON) -env_option(MITK_USE_GLEW "Use the GLEW library" ON) -env_option(MITK_USE_Boost "Use the Boost C++ library" OFF) -env_option(MITK_USE_BLUEBERRY "Build the BlueBerry platform" ON) -env_option(MITK_USE_CTK "Use CTK in MITK" ON) -env_option(MITK_USE_DCMTK "EXPERIMENTAL, superbuild only: Use DCMTK in MITK" ${MITK_USE_CTK}) -env_option(MITK_USE_OpenCV "Use Intel's OpenCV library" OFF) -env_option(MITK_USE_OpenCL "Use OpenCL GPU-Computing library" OFF) -env_option(MITK_USE_Poco "Use the Poco library" ON) -env_option(MITK_USE_Redland "Use the Redland RDF library" OFF) -env_option(MITK_USE_SOFA "Use Simulation Open Framework Architecture" OFF) -env_option(MITK_USE_Python "Use Python wrapping in MITK" OFF) -env_option(MITK_USE_SimpleITK "Use the SimpleITK library" OFF) -set(MITK_USE_CableSwig ${MITK_USE_Python}) +set_property(GLOBAL PROPERTY MITK_EXTERNAL_PROJECTS "") -option(MITK_ENABLE_PIC_READER "Enable support for reading the DKFZ pic file format." ON) +mitkFunctionAddExternalProject(NAME Poco ON COMPONENTS Foundation Util XML) +mitkFunctionAddExternalProject(NAME Boost OFF DOC "Use the Boost C++ library") +mitkFunctionAddExternalProject(NAME DCMTK ON DOC "EXPERIMENTAL, superbuild only: Use DCMTK in MITK") -set(_buildConfigs "Custom") +mitkFunctionAddExternalProject(NAME tinyxml ON ADVANCED) +mitkFunctionAddExternalProject(NAME GDCM ON ADVANCED) +mitkFunctionAddExternalProject(NAME GLUT OFF ADVANCED) +mitkFunctionAddExternalProject(NAME Raptor2 OFF ADVANCED) +mitkFunctionAddExternalProject(NAME Eigen ON ADVANCED DOC "Use the Eigen library") +mitkFunctionAddExternalProject(NAME GLEW ON ADVANCED DOC "Use the GLEW library") +mitkFunctionAddExternalProject(NAME ANN ON ADVANCED DOC "Use Approximate Nearest Neighbor Library") +mitkFunctionAddExternalProject(NAME CppUnit ON ADVANCED DOC "Use CppUnit for unit tests") -file(GLOB _buildConfigFiles CMake/BuildConfigurations/*.cmake) +mitkFunctionAddExternalProject(NAME PCRE OFF ADVANCED NO_PACKAGE) +mitkFunctionAddExternalProject(NAME ZLIB OFF ADVANCED NO_PACKAGE NO_CACHE) -foreach(_buildConfigFile ${_buildConfigFiles}) - get_filename_component(_buildConfigFile ${_buildConfigFile} NAME_WE) - list(APPEND _buildConfigs ${_buildConfigFile}) -endforeach() +# ----------------------------------------- +# The following external projects must be +# ordered according to their +# inter-dependencies -set(MITK_BUILD_CONFIGURATION "Custom" CACHE STRING "Use pre-defined MITK configurations") -set_property(CACHE MITK_BUILD_CONFIGURATION PROPERTY STRINGS ${_buildConfigs}) +if(MITK_USE_QT) + mitkFunctionAddExternalProject(NAME Qwt ON ADVANCED) +endif() -mitkFunctionEnableBuildConfiguration() +mitkFunctionAddExternalProject(NAME SWIG OFF ADVANCED NO_PACKAGE DEPENDS PCRE) +mitkFunctionAddExternalProject(NAME Python OFF NO_PACKAGE DEPENDS SWIG DOC "Use Python wrapping in MITK") +mitkFunctionAddExternalProject(NAME Numpy OFF ADVANCED NO_PACKAGE) +mitkFunctionAddExternalProject(NAME OpenCV OFF) -mitkFunctionCreateWhitelistPaths(MITK) -mitkFunctionFindWhitelists(MITK) +# These are "hard" dependencies and always set to ON +mitkFunctionAddExternalProject(NAME ITK ON NO_CACHE) +mitkFunctionAddExternalProject(NAME VTK ON NO_CACHE) -mark_as_advanced(MITK_BUILD_ALL_APPS - MITK_USE_CppUnit - MITK_USE_GLEW - MITK_USE_CTK - MITK_USE_DCMTK - MITK_ENABLE_PIC_READER - MITK_BUILD_CONFIGURATION - ) +mitkFunctionAddExternalProject(NAME SimpleITK OFF DEPENDS ITK GDCM SWIG) +mitkFunctionAddExternalProject(NAME ACVD OFF DOC "Use Approximated Centroidal Voronoi Diagrams") +mitkFunctionAddExternalProject(NAME CTK ON DEPENDS DCMTK DOC "Use CTK in MITK") +mitkFunctionAddExternalProject(NAME Rasqal OFF DEPENDS Raptor2 PCRE ADVANCED) +mitkFunctionAddExternalProject(NAME Redland OFF DEPENDS Rasqal DOC "Use the Redland RDF library") +mitkFunctionAddExternalProject(NAME SOFA OFF DEPENDS GLUT Boost DOC "Use Simulation Open Framework Architecture") -if(MITK_USE_Python) - if(APPLE) - message(WARNING "Python wrapping is unsuported on mac OSX!") - set(MITK_USE_Python OFF CACHE BOOL "Use Python wrapping in MITK" FORCE) - else() - option(MITK_USE_SYSTEM_PYTHON "Use the system python runtime" OFF) - # SimpleITK is required when python is enabled - set(MITK_USE_SimpleITK ON CACHE BOOL "Use the SimpleITK library" FORCE) - if(MITK_USE_SYSTEM_PYTHON) - FIND_PACKAGE(PythonLibs REQUIRED) - FIND_PACKAGE(PythonInterp REQUIRED) - else() - FIND_PACKAGE(PythonLibs) - FIND_PACKAGE(PythonInterp) - endif() - endif() -endif() +# ----------------------------------------- +# Custom dependency logic if(MITK_USE_Boost) option(MITK_USE_SYSTEM_Boost "Use the system Boost" OFF) set(MITK_USE_Boost_LIBRARIES "" CACHE STRING "A semi-colon separated list of required Boost libraries") endif() -if(MITK_USE_BLUEBERRY) - option(MITK_BUILD_ALL_PLUGINS "Build all MITK plugins" OFF) - mark_as_advanced(MITK_BUILD_ALL_PLUGINS) - - if(NOT MITK_USE_CTK) - message("> Forcing MITK_USE_CTK to ON because of MITK_USE_BLUEBERRY") - set(MITK_USE_CTK ON CACHE BOOL "Use CTK in MITK" FORCE) - endif() -endif() - -if(MITK_USE_CTK AND NOT MITK_USE_DCMTK) - message("> Forcing MITK_USE_DCMTK to ON because of MITK_USE_CTK") - set(MITK_USE_DCMTK ON CACHE BOOL "Use DCMTK in MITK" FORCE) -endif() - if(MITK_USE_SOFA) # SOFA requires at least CMake 2.8.8 set(SOFA_CMAKE_VERSION 2.8.8) if(${CMAKE_VERSION} VERSION_LESS ${SOFA_CMAKE_VERSION}) set(MITK_USE_SOFA OFF CACHE BOOL "" FORCE) message(WARNING "Switched off MITK_USE_SOFA\n Minimum required CMake version: ${SOFA_CMAKE_VERSION}\n Installed CMake version: ${CMAKE_VERSION}") endif() # SOFA/ITK combination requires at least MSVC 2010 if(MSVC_VERSION AND MSVC_VERSION LESS 1600) set(MITK_USE_SOFA OFF CACHE BOOL "" FORCE) message(WARNING "Switched off MITK_USE_SOFA\n MSVC versions less than 2010 are not supported.") endif() # SOFA requires boost library if(MITK_USE_SOFA AND NOT MITK_USE_Boost) - message("Forcing MITK_USE_Boost to ON because of MITK_USE_SOFA") + message("> Forcing MITK_USE_Boost to ON because of MITK_USE_SOFA") set(MITK_USE_Boost ON CACHE BOOL "" FORCE) endif() # SOFA requires boost system library list(FIND MITK_USE_Boost_LIBRARIES system _result) if(_result LESS 0) - message("Adding 'system' to MITK_USE_Boost_LIBRARIES.") + message("> Adding 'system' to MITK_USE_Boost_LIBRARIES.") list(APPEND MITK_USE_Boost_LIBRARIES system) endif() # SOFA requires boost thread library list(FIND MITK_USE_Boost_LIBRARIES thread _result) if(_result LESS 0) - message("Adding 'thread' to MITK_USE_Boost_LIBRARIES.") + message("> Adding 'thread' to MITK_USE_Boost_LIBRARIES.") list(APPEND MITK_USE_Boost_LIBRARIES thread) endif() # Simulation plugin requires boost chrono library list(FIND MITK_USE_Boost_LIBRARIES chrono _result) if(_result LESS 0) - message("Adding 'chrono' to MITK_USE_Boost_LIBRARIES.") + message("> Adding 'chrono' to MITK_USE_Boost_LIBRARIES.") list(APPEND MITK_USE_Boost_LIBRARIES chrono) endif() set(MITK_USE_Boost_LIBRARIES ${MITK_USE_Boost_LIBRARIES} CACHE STRING "" FORCE) # Allow setting external SOFA plugins directory and SOFA plugins set(MITK_USE_SOFA_PLUGINS_DIR ${MITK_USE_SOFA_PLUGINS_DIR} CACHE PATH "External SOFA plugins directory" FORCE) set(MITK_USE_SOFA_PLUGINS ${MITK_USE_SOFA_PLUGINS} CACHE PATH "List of semicolon-separated plugin names" FORCE) endif() +if(MITK_USE_Python AND NOT MITK_USE_SYSTEM_PYTHON) + set(MITK_USE_ZLIB ON) + if(NOT MITK_USE_Numpy) + message("> Forcing MITK_USE_Numpy to ON because of MITK_USE_Python") + set(MITK_USE_Numpy ON CACHE BOOL "Use Numpy" FORCE) + endif() + if(NOT MITK_USE_SimpleITK) + message("> Forcing MITK_USE_SimpleITK to ON because of MITK_USE_Python") + set(MITK_USE_Numpy ON CACHE BOOL "Use Numpy" FORCE) + endif() + + if(APPLE) + message(WARNING "Python wrapping is unsuported on mac OSX!") + set(MITK_USE_Python OFF CACHE BOOL "Use Python wrapping in MITK" FORCE) + else() + option(MITK_USE_SYSTEM_PYTHON "Use the system python runtime" OFF) + if(MITK_USE_SYSTEM_PYTHON) + find_package(PythonLibs REQUIRED) + find_package(PythonInterp REQUIRED) + endif() + endif() +endif() + +if(BUILD_TESTING AND NOT MITK_USE_CppUnit) + message("> Forcing MITK_USE_CppUnit to ON because BUILD_TESTING=ON") + set(MITK_USE_CppUnit ON CACHE BOOL "Use CppUnit for unit tests" FORCE) +endif() + +# ----------------------------------------- +# Other MITK_USE_* options not related to +# external projects build via the +# MITK superbuild + +env_option(MITK_USE_BLUEBERRY "Build the BlueBerry platform" ON) +env_option(MITK_USE_OpenCL "Use OpenCL GPU-Computing library" OFF) + +if(MITK_USE_BLUEBERRY) + option(MITK_BUILD_ALL_PLUGINS "Build all MITK plugins" OFF) + mark_as_advanced(MITK_BUILD_ALL_PLUGINS) + + if(NOT MITK_USE_CTK) + message("> Forcing MITK_USE_CTK to ON because of MITK_USE_BLUEBERRY") + set(MITK_USE_CTK ON CACHE BOOL "Use CTK in MITK" FORCE) + endif() +endif() + +#----------------------------------------------------------------------------- +# Build configurations +#----------------------------------------------------------------------------- + +set(_buildConfigs "Custom") + +file(GLOB _buildConfigFiles CMake/BuildConfigurations/*.cmake) + +foreach(_buildConfigFile ${_buildConfigFiles}) + get_filename_component(_buildConfigFile ${_buildConfigFile} NAME_WE) + list(APPEND _buildConfigs ${_buildConfigFile}) +endforeach() + +set(MITK_BUILD_CONFIGURATION "Custom" CACHE STRING "Use pre-defined MITK configurations") +mark_as_advanced(MITK_BUILD_CONFIGURATION) +set_property(CACHE MITK_BUILD_CONFIGURATION PROPERTY STRINGS ${_buildConfigs}) + +mitkFunctionEnableBuildConfiguration() + +mitkFunctionCreateWhitelistPaths(MITK) +mitkFunctionFindWhitelists(MITK) + +#----------------------------------------------------------------------------- +# Pixel type multiplexing +#----------------------------------------------------------------------------- + # Customize the default pixel types for multiplex macros set(MITK_ACCESSBYITK_INTEGRAL_PIXEL_TYPES "int, unsigned int, short, unsigned short, char, unsigned char" CACHE STRING "List of integral pixel types used in AccessByItk and InstantiateAccessFunction macros") set(MITK_ACCESSBYITK_FLOATING_PIXEL_TYPES "double, float" CACHE STRING "List of floating pixel types used in AccessByItk and InstantiateAccessFunction macros") set(MITK_ACCESSBYITK_COMPOSITE_PIXEL_TYPES "itk::RGBPixel, itk::RGBAPixel" CACHE STRING "List of composite pixel types used in AccessByItk and InstantiateAccessFunction macros") set(MITK_ACCESSBYITK_DIMENSIONS "2,3" CACHE STRING "List of dimensions used in AccessByItk and InstantiateAccessFunction macros") mark_as_advanced(MITK_ACCESSBYITK_INTEGRAL_PIXEL_TYPES MITK_ACCESSBYITK_FLOATING_PIXEL_TYPES MITK_ACCESSBYITK_COMPOSITE_PIXEL_TYPES MITK_ACCESSBYITK_DIMENSIONS ) # consistency checks if(NOT MITK_ACCESSBYITK_INTEGRAL_PIXEL_TYPES) set(MITK_ACCESSBYITK_INTEGRAL_PIXEL_TYPES "int, unsigned int, short, unsigned short, char, unsigned char" CACHE STRING "List of integral pixel types used in AccessByItk and InstantiateAccessFunction macros" FORCE) endif() if(NOT MITK_ACCESSBYITK_FLOATING_PIXEL_TYPES) set(MITK_ACCESSBYITK_FLOATING_PIXEL_TYPES "double, float" CACHE STRING "List of floating pixel types used in AccessByItk and InstantiateAccessFunction macros" FORCE) endif() if(NOT MITK_ACCESSBYITK_COMPOSITE_PIXEL_TYPES) set(MITK_ACCESSBYITK_COMPOSITE_PIXEL_TYPES "itk::RGBPixel, itk::RGBAPixel" CACHE STRING "List of composite pixel types used in AccessByItk and InstantiateAccessFunction macros" FORCE) endif() if(NOT MITK_ACCESSBYITK_VECTOR_PIXEL_TYPES) string(REPLACE "," ";" _integral_types ${MITK_ACCESSBYITK_INTEGRAL_PIXEL_TYPES}) string(REPLACE "," ";" _floating_types ${MITK_ACCESSBYITK_FLOATING_PIXEL_TYPES}) foreach(_scalar_type ${_integral_types} ${_floating_types}) set(MITK_ACCESSBYITK_VECTOR_PIXEL_TYPES "${MITK_ACCESSBYITK_VECTOR_PIXEL_TYPES}itk::VariableLengthVector<${_scalar_type}>,") endforeach() string(LENGTH "${MITK_ACCESSBYITK_VECTOR_PIXEL_TYPES}" _length) math(EXPR _length "${_length} - 1") string(SUBSTRING "${MITK_ACCESSBYITK_VECTOR_PIXEL_TYPES}" 0 ${_length} MITK_ACCESSBYITK_VECTOR_PIXEL_TYPES) set(MITK_ACCESSBYITK_VECTOR_PIXEL_TYPES ${MITK_ACCESSBYITK_VECTOR_PIXEL_TYPES} CACHE STRING "List of vector pixel types used in AccessByItk and InstantiateAccessFunction macros for itk::VectorImage types" FORCE) endif() if(NOT MITK_ACCESSBYITK_DIMENSIONS) set(MITK_ACCESSBYITK_DIMENSIONS "2,3" CACHE STRING "List of dimensions used in AccessByItk and InstantiateAccessFunction macros") endif() #----------------------------------------------------------------------------- # 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-ToF MITK-DTI MITK-Registration MITK-Modules # all modules not contained in a specific subproject MITK-Plugins # all plugins not contained in a specific subproject MITK-Examples Unlabeled # special "subproject" catching all unlabeled targets and tests ) # Configure CTestConfigSubProject.cmake that could be used by CTest scripts configure_file(${MITK_SOURCE_DIR}/CTestConfigSubProject.cmake.in ${MITK_BINARY_DIR}/CTestConfigSubProject.cmake) if(CTEST_PROJECT_ADDITIONAL_TARGETS) # those targets will be executed at the end of the ctest driver script # and they also get their own subproject label set(subproject_list "${CTEST_PROJECT_SUBPROJECTS};${CTEST_PROJECT_ADDITIONAL_TARGETS}") else() set(subproject_list "${CTEST_PROJECT_SUBPROJECTS}") endif() # Generate Project.xml file expected by the CTest driver script mitkFunctionGenerateProjectXml(${MITK_BINARY_DIR} MITK "${subproject_list}" ${MITK_USE_SUPERBUILD}) #----------------------------------------------------------------------------- # Superbuild script #----------------------------------------------------------------------------- if(MITK_USE_SUPERBUILD) include("${CMAKE_CURRENT_SOURCE_DIR}/SuperBuild.cmake") # Print configuration summary message("\n\n") feature_summary( DESCRIPTION "------- FEATURE SUMMARY FOR ${PROJECT_NAME} -------" WHAT ALL) return() endif() #***************************************************************************** #**************************** END OF SUPERBUILD **************************** #***************************************************************************** #----------------------------------------------------------------------------- # CMake function(s) and macro(s) #----------------------------------------------------------------------------- include(WriteBasicConfigVersionFile) include(CheckCXXSourceCompiles) include(GenerateExportHeader) -include(CMakeParseArguments) include(mitkFunctionCheckCompilerFlags) include(mitkFunctionGetGccVersion) include(mitkFunctionSuppressWarnings) # includes several functions include(mitkFunctionOrganizeSources) include(mitkFunctionGetVersion) include(mitkFunctionGetVersionDescription) include(mitkFunctionCreateWindowsBatchScript) include(mitkFunctionInstallProvisioningFiles) include(mitkFunctionInstallAutoLoadModules) include(mitkFunctionGetLibrarySearchPaths) include(mitkFunctionCompileSnippets) include(mitkFunctionUseModules) include(mitkFunctionCheckModuleDependencies) include(mitkFunctionCreateModule) include(mitkMacroCreateExecutable) include(mitkMacroCreateModuleTests) include(mitkFunctionAddCustomModuleTest) include(mitkMacroMultiplexPicType) include(mitkMacroInstall) include(mitkMacroInstallHelperApp) include(mitkMacroInstallTargets) include(mitkMacroGenerateToolsLibrary) include(mitkMacroGetLinuxDistribution) include(mitkMacroGetPMDPlatformString) include(mitkMacroConfigureItkPixelTypes) #----------------------------------------------------------------------------- # Global CMake variables #----------------------------------------------------------------------------- set(MITK_CXX_STANDARD 11) # help keeping cross-platform compatibility # CMake 3.1 does not yet know how to handle AppleClang... # See http://public.kitware.com/Bug/view.php?id=15355 if(NOT MSVC AND NOT CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang") set(CMAKE_CXX_EXTENSIONS 0) set(CMAKE_CXX_STANDARD ${MITK_CXX_STANDARD}) set(CMAKE_CXX_STANDARD_REQUIRED 1) endif() # Required and enabled C++11 features for all MITK code. # These are added as PUBLIC compile features to all MITK modules. set(MITK_CXX_FEATURES cxx_auto_type cxx_nullptr cxx_override) if(NOT DEFINED CMAKE_DEBUG_POSTFIX) # We can't do this yet because the CTK Plugin Framework # cannot cope with a postfix yet. #set(CMAKE_DEBUG_POSTFIX d) endif() #----------------------------------------------------------------------------- # Output directories. #----------------------------------------------------------------------------- set(_default_LIBRARY_output_dir lib) set(_default_RUNTIME_output_dir bin) set(_default_ARCHIVE_output_dir lib) foreach(type LIBRARY RUNTIME ARCHIVE) # Make sure the directory exists if(MITK_CMAKE_${type}_OUTPUT_DIRECTORY AND NOT EXISTS ${MITK_CMAKE_${type}_OUTPUT_DIRECTORY}) message("Creating directory MITK_CMAKE_${type}_OUTPUT_DIRECTORY: ${MITK_CMAKE_${type}_OUTPUT_DIRECTORY}") file(MAKE_DIRECTORY "${MITK_CMAKE_${type}_OUTPUT_DIRECTORY}") endif() if(MITK_CMAKE_${type}_OUTPUT_DIRECTORY) set(CMAKE_${type}_OUTPUT_DIRECTORY ${MITK_CMAKE_${type}_OUTPUT_DIRECTORY}) else() set(CMAKE_${type}_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/${_default_${type}_output_dir}) set(MITK_CMAKE_${type}_OUTPUT_DIRECTORY ${CMAKE_${type}_OUTPUT_DIRECTORY}) endif() set(CMAKE_${type}_OUTPUT_DIRECTORY ${CMAKE_${type}_OUTPUT_DIRECTORY} CACHE INTERNAL "Output directory for ${type} files.") mark_as_advanced(CMAKE_${type}_OUTPUT_DIRECTORY) endforeach() #----------------------------------------------------------------------------- # Set MITK specific options and variables (NOT available during superbuild) #----------------------------------------------------------------------------- # ASK THE USER TO SHOW THE CONSOLE WINDOW FOR CoreApp and mitkWorkbench 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) if(NOT MITK_FAST_TESTING) if(DEFINED MITK_CTEST_SCRIPT_MODE AND (MITK_CTEST_SCRIPT_MODE STREQUAL "continuous" OR MITK_CTEST_SCRIPT_MODE STREQUAL "experimental") ) set(MITK_FAST_TESTING 1) endif() endif() # MITK_VERSION set(MITK_VERSION_STRING "${MITK_VERSION_MAJOR}.${MITK_VERSION_MINOR}.${MITK_VERSION_PATCH}") if(MITK_VERSION_PATCH STREQUAL "99") set(MITK_VERSION_STRING "${MITK_VERSION_STRING}-${MITK_REVISION_SHORTID}") endif() # Needed early on for redirecting the BlueBerry documentation output dir set(MITK_DOXYGEN_OUTPUT_DIR ${PROJECT_BINARY_DIR}/Documentation/Doxygen CACHE PATH "Output directory for doxygen generated documentation." ) if(NOT UNIX AND NOT MINGW) set(MITK_WIN32_FORCE_STATIC "STATIC" CACHE INTERNAL "Use this variable to always build static libraries on non-unix platforms") endif() if(MITK_BUILD_ALL_PLUGINS) set(MITK_BUILD_ALL_PLUGINS_OPTION "FORCE_BUILD_ALL") endif() # Configure pixel types used for ITK image access multiplexing mitkMacroConfigureItkPixelTypes() # Configure module naming conventions set(MITK_MODULE_NAME_REGEX_MATCH "^[A-Z].*$") set(MITK_MODULE_NAME_REGEX_NOT_MATCH "^[Mm][Ii][Tt][Kk].*$") set(MITK_MODULE_NAME_PREFIX "Mitk") set(MITK_MODULE_NAME_DEFAULTS_TO_DIRECTORY_NAME 1) #----------------------------------------------------------------------------- # Get MITK version info #----------------------------------------------------------------------------- mitkFunctionGetVersion(${MITK_SOURCE_DIR} MITK) mitkFunctionGetVersionDescription(${MITK_SOURCE_DIR} MITK) #----------------------------------------------------------------------------- # Installation preparation # # These should be set before any MITK install macros are used #----------------------------------------------------------------------------- # on Mac OSX all BlueBerry plugins get copied into every # application bundle (.app directory) specified here if(MITK_USE_BLUEBERRY AND APPLE) include("${CMAKE_CURRENT_SOURCE_DIR}/Applications/AppList.cmake") foreach(mitk_app ${MITK_APPS}) # extract option_name string(REPLACE "^^" "\\;" target_info ${mitk_app}) set(target_info_list ${target_info}) list(GET target_info_list 1 option_name) list(GET target_info_list 0 app_name) # check if the application is enabled if(${option_name} OR MITK_BUILD_ALL_APPS) set(MACOSX_BUNDLE_NAMES ${MACOSX_BUNDLE_NAMES} Mitk${app_name}) endif() endforeach() 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 "${COVERAGE_C_FLAGS}") set(MITK_C_FLAGS_DEBUG ) set(MITK_C_FLAGS_RELEASE ) set(MITK_CXX_FLAGS "${COVERAGE_CXX_FLAGS}") set(MITK_CXX_FLAGS_DEBUG ) set(MITK_CXX_FLAGS_RELEASE ) set(MITK_EXE_LINKER_FLAGS ) set(MITK_SHARED_LINKER_FLAGS ) mitkFunctionCheckCompilerFlags("-std=c++11" MITK_CXX_FLAGS) if(WIN32) set(MITK_CXX_FLAGS "${MITK_CXX_FLAGS} -D_WIN32_WINNT=0x0501 -DPOCO_NO_UNWINDOWS -DWIN32_LEAN_AND_MEAN -DNOMINMAX") mitkFunctionCheckCompilerFlags("/wd4005" MITK_CXX_FLAGS) # warning C4005: macro redefinition mitkFunctionCheckCompilerFlags("/wd4231" MITK_CXX_FLAGS) # warning C4231: nonstandard extension used : 'extern' before template explicit instantiation # the following line should be removed after fixing bug 17637 mitkFunctionCheckCompilerFlags("/wd4316" MITK_CXX_FLAGS) # warning C4316: object alignment on heap endif() if(NOT MSVC_VERSION) foreach(_flag -Wall -Wextra -Wpointer-arith -Winvalid-pch -Wcast-align -Wwrite-strings -Wno-error=gnu -Wno-error=unknown-pragmas # The strict-overflow warning is generated by ITK template code -Wno-error=strict-overflow -Woverloaded-virtual -Wstrict-null-sentinel #-Wold-style-cast #-Wsign-promo # the following two lines should be removed after ITK-3097 has # been resolved, see also MITK bug 15279 -Wno-unused-local-typedefs -Wno-array-bounds -fdiagnostics-show-option ) mitkFunctionCheckCAndCXXCompilerFlags(${_flag} MITK_C_FLAGS MITK_CXX_FLAGS) endforeach() endif() if(CMAKE_COMPILER_IS_GNUCXX AND NOT APPLE) mitkFunctionCheckCompilerFlags("-Wl,--no-undefined" MITK_SHARED_LINKER_FLAGS) mitkFunctionCheckCompilerFlags("-Wl,--as-needed" MITK_SHARED_LINKER_FLAGS) endif() if(CMAKE_COMPILER_IS_GNUCXX) 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")) mitkFunctionCheckCAndCXXCompilerFlags("-fstack-protector-all" MITK_C_FLAGS MITK_CXX_FLAGS) endif() if(MINGW) # suppress warnings about auto imported symbols set(MITK_SHARED_LINKER_FLAGS "-Wl,--enable-auto-import ${MITK_SHARED_LINKER_FLAGS}") endif() set(MITK_CXX_FLAGS_RELEASE "-D_FORTIFY_SOURCE=2 ${MITK_CXX_FLAGS_RELEASE}") endif() set(MITK_MODULE_LINKER_FLAGS ${MITK_SHARED_LINKER_FLAGS}) set(MITK_EXE_LINKER_FLAGS ${MITK_SHARED_LINKER_FLAGS}) #----------------------------------------------------------------------------- # MITK Packages #----------------------------------------------------------------------------- set(MITK_MODULES_PACKAGE_DEPENDS_DIR ${MITK_SOURCE_DIR}/CMake/PackageDepends) set(MODULES_PACKAGE_DEPENDS_DIRS ${MITK_MODULES_PACKAGE_DEPENDS_DIR}) -find_package(GDCM PATHS ${GDCM_DIR} REQUIRED) -if(MITK_USE_OpenCV) - find_package(OpenCV PATHS ${OpenCV_DIR} REQUIRED) +# This property is populated at the top half of this file +get_property(MITK_EXTERNAL_PROJECTS GLOBAL PROPERTY MITK_EXTERNAL_PROJECTS) +foreach(ep ${MITK_EXTERNAL_PROJECTS}) + get_property(_package GLOBAL PROPERTY MITK_${ep}_PACKAGE) + get_property(_components GLOBAL PROPERTY MITK_${ep}_COMPONENTS) + if(MITK_USE_${ep} AND _package) + if(_components) + find_package(${_package} COMPONENTS ${_components} REQUIRED CONFIG) + else() + # Prefer config mode first because it finds external + # Config.cmake files pointed at by _DIR variables. + # Otherwise, existing Find.cmake files could file + # (e.g. in the case of GLEW and the FindGLEW.cmake file shipped + # with CMake). + find_package(${_package} QUIET CONFIG) + string(TOUPPER "${_package}" _package_uc) + if(NOT (${_package}_FOUND OR ${_package_uc}_FOUND)) + find_package(${_package} REQUIRED) + endif() + endif() + endif() +endforeach() + +if(MITK_USE_Python) + find_package(PythonLibs REQUIRED) + find_package(PythonInterp REQUIRED) endif() + if(MITK_USE_SOFA) # The SOFAConfig.cmake file does not provide exported targets or # libraries with absolute paths, hence we need to make the link # directories globally available until the SOFAConfig.cmake file # supports a proper mechanism for handling targets. # The same code is needed in MITKConfig.cmake. - find_package(SOFA PATHS ${SOFA_DIR} CONFIG REQUIRED) link_directories(${SOFA_LIBRARY_DIRS}) endif() # Qt support if(MITK_USE_QT) if(DESIRED_QT_VERSION MATCHES 4) find_package(Qt4 ${MITK_QT4_MINIMUM_VERSION} REQUIRED) elseif(DESIRED_QT_VERSION MATCHES 5) find_package(Qt5Core ${MITK_QT5_MINIMUM_VERSION} REQUIRED) # at least Core required endif() endif() +# Ensure that the MITK CMake module path comes first +set(CMAKE_MODULE_PATH + ${MITK_CMAKE_DIR} + ${CMAKE_MODULE_PATH} + ) + #----------------------------------------------------------------------------- # Testing #----------------------------------------------------------------------------- if(BUILD_TESTING) enable_testing() include(CTest) mark_as_advanced(TCL_TCLSH DART_ROOT) option(MITK_ENABLE_RENDERING_TESTING OFF "Enable the MITK rendering tests. Requires x-server in Linux.") #Rendering testing does not work for Linux nightlies, thus it is disabled per default #and activated for Mac and Windows. if(WIN32 OR APPLE) set(MITK_ENABLE_RENDERING_TESTING ON) endif() mark_as_advanced( MITK_ENABLE_RENDERING_TESTING ) # 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() # Test the external project template if(MITK_USE_BLUEBERRY) include(mitkTestProjectTemplate) endif() # Test the package target include(mitkPackageTest) endif() configure_file(mitkTestingConfig.h.in ${MITK_BINARY_DIR}/mitkTestingConfig.h) #----------------------------------------------------------------------------- # 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() #----------------------------------------------------------------------------- # Set C/CXX and linker flags for MITK code #----------------------------------------------------------------------------- set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${MITK_CXX_FLAGS}") set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} ${MITK_CXX_FLAGS_DEBUG}") set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} ${MITK_CXX_FLAGS_RELEASE}") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${MITK_C_FLAGS}") set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} ${MITK_C_FLAGS_DEBUG}") set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} ${MITK_C_FLAGS_RELEASE}") set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${MITK_EXE_LINKER_FLAGS}") set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} ${MITK_SHARED_LINKER_FLAGS}") set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} ${MITK_MODULE_LINKER_FLAGS}") #----------------------------------------------------------------------------- # Compile Utilities and set-up MITK variables #----------------------------------------------------------------------------- add_subdirectory(Utilities) if(MITK_USE_BLUEBERRY) # We need to hack a little bit because MITK applications may need # to enable certain BlueBerry plug-ins. However, these plug-ins # are validated separately from the MITK plug-ins and know nothing # about potential MITK plug-in dependencies of the applications. Hence # we cannot pass the MITK application list to the BlueBerry # ctkMacroSetupPlugins call but need to extract the BlueBerry dependencies # from the applications and set them explicitly. include("${CMAKE_CURRENT_SOURCE_DIR}/Applications/AppList.cmake") foreach(mitk_app ${MITK_APPS}) # extract target_dir and option_name string(REPLACE "^^" "\\;" target_info ${mitk_app}) set(target_info_list ${target_info}) list(GET target_info_list 0 target_dir) list(GET target_info_list 1 option_name) # check if the application is enabled and if target_libraries.cmake exists if((${option_name} OR MITK_BUILD_ALL_APPS) AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/Applications/${target_dir}/target_libraries.cmake") include("${CMAKE_CURRENT_SOURCE_DIR}/Applications/${target_dir}/target_libraries.cmake") foreach(_target_dep ${target_libraries}) if(_target_dep MATCHES org_blueberry_) string(REPLACE _ . _app_bb_dep ${_target_dep}) # explicitly set the build option for the BlueBerry plug-in set(BLUEBERRY_BUILD_${_app_bb_dep} ON CACHE BOOL "Build the ${_app_bb_dep} plug-in") endif() endforeach() endif() endforeach() set(mbilog_DIR "${mbilog_BINARY_DIR}") if(MITK_BUILD_ALL_PLUGINS) set(BLUEBERRY_BUILD_ALL_PLUGINS ON) endif() set(BLUEBERRY_XPDOC_OUTPUT_DIR ${MITK_DOXYGEN_OUTPUT_DIR}/html/extension-points/html/) add_subdirectory(BlueBerry) set(BlueBerry_DIR ${CMAKE_CURRENT_BINARY_DIR}/BlueBerry CACHE PATH "The directory containing a CMake configuration file for BlueBerry" FORCE) include(mitkMacroCreateCTKPlugin) endif() #----------------------------------------------------------------------------- # Add custom targets representing CDash subprojects #----------------------------------------------------------------------------- foreach(subproject ${CTEST_PROJECT_SUBPROJECTS}) if(NOT TARGET ${subproject} AND NOT subproject MATCHES "Unlabeled") add_custom_target(${subproject}) endif() endforeach() #----------------------------------------------------------------------------- # Add subdirectories #----------------------------------------------------------------------------- add_subdirectory(Modules) if(MITK_USE_BLUEBERRY) find_package(BlueBerry REQUIRED) set(MITK_DEFAULT_SUBPROJECTS MITK-Plugins) # Plug-in testing (needs some work to be enabled again) if(BUILD_TESTING) include(berryTestingHelpers) set(BLUEBERRY_UI_TEST_APP "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/CoreApp") if(TARGET CoreApp) get_target_property(_is_macosx_bundle CoreApp MACOSX_BUNDLE) if(APPLE AND _is_macosx_bundle) set(BLUEBERRY_UI_TEST_APP "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/CoreApp.app/Contents/MacOS/CoreApp") endif() endif() set(BLUEBERRY_TEST_APP_ID "org.mitk.qt.coreapplication") endif() include("${CMAKE_CURRENT_SOURCE_DIR}/Plugins/PluginList.cmake") mitkFunctionWhitelistPlugins(MITK MITK_EXT_PLUGINS) set(mitk_plugins_fullpath "") foreach(mitk_plugin ${MITK_EXT_PLUGINS}) list(APPEND mitk_plugins_fullpath Plugins/${mitk_plugin}) endforeach() if(EXISTS ${MITK_PRIVATE_MODULES}/PluginList.cmake) include(${MITK_PRIVATE_MODULES}/PluginList.cmake) foreach(mitk_plugin ${MITK_PRIVATE_PLUGINS}) list(APPEND mitk_plugins_fullpath ${MITK_PRIVATE_MODULES}/${mitk_plugin}) endforeach() endif() if(MITK_BUILD_EXAMPLES) include("${CMAKE_CURRENT_SOURCE_DIR}/Examples/Plugins/PluginList.cmake") set(mitk_example_plugins_fullpath ) foreach(mitk_example_plugin ${MITK_EXAMPLE_PLUGINS}) list(APPEND mitk_example_plugins_fullpath Examples/Plugins/${mitk_example_plugin}) list(APPEND mitk_plugins_fullpath Examples/Plugins/${mitk_example_plugin}) endforeach() endif() # Specify which plug-ins belong to this project macro(GetMyTargetLibraries all_target_libraries varname) set(re_ctkplugin_mitk "^org_mitk_[a-zA-Z0-9_]+$") set(re_ctkplugin_bb "^org_blueberry_[a-zA-Z0-9_]+$") set(_tmp_list) list(APPEND _tmp_list ${all_target_libraries}) ctkMacroListFilter(_tmp_list re_ctkplugin_mitk re_ctkplugin_bb OUTPUT_VARIABLE ${varname}) endmacro() # Get infos about application directories and build options include("${CMAKE_CURRENT_SOURCE_DIR}/Applications/AppList.cmake") set(mitk_apps_fullpath ) foreach(mitk_app ${MITK_APPS}) string(FIND ${mitk_app} "MITK_BUILD_APP_" _index) string(SUBSTRING ${mitk_app} ${_index} -1 _var) if(${_var}) list(APPEND mitk_apps_fullpath "${CMAKE_CURRENT_SOURCE_DIR}/Applications/${mitk_app}") endif() endforeach() if (mitk_plugins_fullpath) ctkMacroSetupPlugins(${mitk_plugins_fullpath} BUILD_OPTION_PREFIX MITK_BUILD_ APPS ${mitk_apps_fullpath} BUILD_ALL ${MITK_BUILD_ALL_PLUGINS} COMPACT_OPTIONS) endif() set(MITK_PLUGIN_USE_FILE "${MITK_BINARY_DIR}/MitkPluginUseFile.cmake") if(${PROJECT_NAME}_PLUGIN_LIBRARIES) ctkFunctionGeneratePluginUseFile(${MITK_PLUGIN_USE_FILE}) else() file(REMOVE ${MITK_PLUGIN_USE_FILE}) set(MITK_PLUGIN_USE_FILE ) endif() endif() #----------------------------------------------------------------------------- # Documentation #----------------------------------------------------------------------------- add_subdirectory(Documentation) #----------------------------------------------------------------------------- # Installation #----------------------------------------------------------------------------- # set MITK cpack variables # These are the default variables, which can be overwritten ( see below ) include(mitkSetupCPack) set(use_default_config ON) # MITK_APPS is set in Applications/AppList.cmake (included somewhere above # if MITK_USE_BLUEBERRY is set to ON). if(MITK_APPS) set(activated_apps_no 0) list(LENGTH MITK_APPS app_count) # Check how many apps have been enabled # If more than one app has been activated, the we use the # default CPack configuration. Otherwise that apps configuration # will be used, if present. foreach(mitk_app ${MITK_APPS}) # extract option_name string(REPLACE "^^" "\\;" target_info ${mitk_app}) set(target_info_list ${target_info}) list(GET target_info_list 1 option_name) # check if the application is enabled if(${option_name} OR MITK_BUILD_ALL_APPS) MATH(EXPR activated_apps_no "${activated_apps_no} + 1") endif() endforeach() if(app_count EQUAL 1 AND (activated_apps_no EQUAL 1 OR MITK_BUILD_ALL_APPS)) # Corner case if there is only one app in total set(use_project_cpack ON) elseif(activated_apps_no EQUAL 1 AND NOT MITK_BUILD_ALL_APPS) # Only one app is enabled (no "build all" flag set) set(use_project_cpack ON) else() # Less or more then one app is enabled set(use_project_cpack OFF) endif() foreach(mitk_app ${MITK_APPS}) # extract target_dir and option_name string(REPLACE "^^" "\\;" target_info ${mitk_app}) set(target_info_list ${target_info}) list(GET target_info_list 0 target_dir) list(GET target_info_list 1 option_name) # check if the application is enabled if(${option_name} OR MITK_BUILD_ALL_APPS) # check whether application specific configuration files will be used if(use_project_cpack) # use files if they exist if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/Applications/${target_dir}/CPackOptions.cmake") include("${CMAKE_CURRENT_SOURCE_DIR}/Applications/${target_dir}/CPackOptions.cmake") endif() if(EXISTS "${PROJECT_SOURCE_DIR}/Applications/${target_dir}/CPackConfig.cmake.in") set(CPACK_PROJECT_CONFIG_FILE "${PROJECT_BINARY_DIR}/Applications/${target_dir}/CPackConfig.cmake") configure_file(${PROJECT_SOURCE_DIR}/Applications/${target_dir}/CPackConfig.cmake.in ${CPACK_PROJECT_CONFIG_FILE} @ONLY) set(use_default_config OFF) endif() endif() # add link to the list list(APPEND CPACK_CREATE_DESKTOP_LINKS "${target_dir}") endif() endforeach() endif() # if no application specific configuration file was used, use default if(use_default_config) configure_file(${MITK_SOURCE_DIR}/MITKCPackOptions.cmake.in ${MITK_BINARY_DIR}/MITKCPackOptions.cmake @ONLY) set(CPACK_PROJECT_CONFIG_FILE "${MITK_BINARY_DIR}/MITKCPackOptions.cmake") endif() # include CPack model once all variables are set include(CPack) # Additional installation rules include(mitkInstallRules) #----------------------------------------------------------------------------- # Last configuration steps #----------------------------------------------------------------------------- +# ---------------- Export targets ----------------- + set(MITK_EXPORTS_FILE "${MITK_BINARY_DIR}/MitkExports.cmake") file(REMOVE ${MITK_EXPORTS_FILE}) set(targets_to_export) get_property(module_targets GLOBAL PROPERTY MITK_MODULE_TARGETS) if(module_targets) list(APPEND targets_to_export ${module_targets}) endif() if(MITK_USE_BLUEBERRY) if(MITK_PLUGIN_LIBRARIES) list(APPEND targets_to_export ${MITK_PLUGIN_LIBRARIES}) endif() endif() export(TARGETS ${targets_to_export} APPEND FILE ${MITK_EXPORTS_FILE}) set(MITK_EXPORTED_TARGET_PROPERTIES ) foreach(target_to_export ${targets_to_export}) get_target_property(autoload_targets ${target_to_export} MITK_AUTOLOAD_TARGETS) if(autoload_targets) set(MITK_EXPORTED_TARGET_PROPERTIES "${MITK_EXPORTED_TARGET_PROPERTIES} set_target_properties(${target_to_export} PROPERTIES MITK_AUTOLOAD_TARGETS \"${autoload_targets}\")") endif() get_target_property(autoload_dir ${target_to_export} MITK_AUTOLOAD_DIRECTORY) if(autoload_dir) set(MITK_EXPORTED_TARGET_PROPERTIES "${MITK_EXPORTED_TARGET_PROPERTIES} set_target_properties(${target_to_export} PROPERTIES MITK_AUTOLOAD_DIRECTORY \"${autoload_dir}\")") endif() get_target_property(deprecated_module ${target_to_export} MITK_MODULE_DEPRECATED_SINCE) if(deprecated_module) set(MITK_EXPORTED_TARGET_PROPERTIES "${MITK_EXPORTED_TARGET_PROPERTIES} set_target_properties(${target_to_export} PROPERTIES MITK_MODULE_DEPRECATED_SINCE \"${deprecated_module}\")") endif() endforeach() +# ---------------- External projects ----------------- + get_property(MITK_ADDITIONAL_LIBRARY_SEARCH_PATHS_CONFIG GLOBAL PROPERTY MITK_ADDITIONAL_LIBRARY_SEARCH_PATHS) +set(MITK_CONFIG_EXTERNAL_PROJECTS ) +#string(REPLACE "^^" ";" _mitk_external_projects ${MITK_EXTERNAL_PROJECTS}) + +foreach(ep ${MITK_EXTERNAL_PROJECTS}) + get_property(_components GLOBAL PROPERTY MITK_${ep}_COMPONENTS) + set(MITK_CONFIG_EXTERNAL_PROJECTS "${MITK_CONFIG_EXTERNAL_PROJECTS} +set(MITK_USE_${ep} ${MITK_USE_${ep}}) +set(MITK_${ep}_DIR \"${${ep}_DIR}\") +set(MITK_${ep}_COMPONENTS ${_components}) +") +endforeach() + +foreach(ep ${MITK_EXTERNAL_PROJECTS}) + get_property(_package GLOBAL PROPERTY MITK_${ep}_PACKAGE) + get_property(_components GLOBAL PROPERTY MITK_${ep}_COMPONENTS) + if(_components) + set(_components_arg COMPONENTS \${_components}) + else() + set(_components_arg) + endif() + + if(_package) + set(MITK_CONFIG_EXTERNAL_PROJECTS "${MITK_CONFIG_EXTERNAL_PROJECTS} +if(MITK_USE_${ep}) + set(${ep}_DIR \${MITK_${ep}_DIR}) + if(MITK_${ep}_COMPONENTS) + mitkMacroFindDependency(${_package} COMPONENTS \${MITK_${ep}_COMPONENTS}) + else() + mitkMacroFindDependency(${_package}) + endif() +endif()") + endif() +endforeach() + + +# ---------------- Tools ----------------- + 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 files ----------------- + configure_file(mitkVersion.h.in ${MITK_BINARY_DIR}/mitkVersion.h) configure_file(mitkConfig.h.in ${MITK_BINARY_DIR}/mitkConfig.h) 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) write_basic_config_version_file(${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake VERSION ${MITK_VERSION_STRING} COMPATIBILITY AnyNewerVersion) # If we are under Windows, create two batch files which correctly # set up the environment for the application and for Visual Studio if(WIN32) include(mitkFunctionCreateWindowsBatchScript) set(VS_SOLUTION_FILE "${PROJECT_BINARY_DIR}/${PROJECT_NAME}.sln") foreach(VS_BUILD_TYPE debug release) mitkFunctionCreateWindowsBatchScript("${MITK_SOURCE_DIR}/CMake/StartVS.bat.in" ${PROJECT_BINARY_DIR}/StartVS_${VS_BUILD_TYPE}.bat ${VS_BUILD_TYPE}) endforeach() endif(WIN32) #----------------------------------------------------------------------------- # MITK Applications #----------------------------------------------------------------------------- # This must come after MITKConfig.h was generated, since applications # might do a find_package(MITK REQUIRED). add_subdirectory(Applications) #----------------------------------------------------------------------------- # MITK Examples #----------------------------------------------------------------------------- if(MITK_BUILD_EXAMPLES) # This must come after MITKConfig.h was generated, since applications # might do a find_package(MITK REQUIRED). add_subdirectory(Examples) endif() #----------------------------------------------------------------------------- # Print configuration summary #----------------------------------------------------------------------------- message("\n\n") feature_summary( DESCRIPTION "------- FEATURE SUMMARY FOR ${PROJECT_NAME} -------" WHAT ALL ) diff --git a/MITKConfig.cmake.in b/MITKConfig.cmake.in index f576192e5b..4f3e7a418a 100644 --- a/MITKConfig.cmake.in +++ b/MITKConfig.cmake.in @@ -1,258 +1,290 @@ if(CMAKE_VERSION VERSION_LESS @MITK_CMAKE_MINIMUM_REQUIRED_VERSION@) message(FATAL_ERROR "MITK requires at least CMake Version @MITK_CMAKE_MINIMUM_REQUIRED_VERSION@") endif() +# The MITK version number +set(MITK_VERSION_MAJOR "@MITK_VERSION_MAJOR@") +set(MITK_VERSION_MINOR "@MITK_VERSION_MINOR@") +set(MITK_VERSION_PATCH "@MITK_VERSION_PATCH@") +set(MITK_VERSION_STRING "@MITK_VERSION_STRING@") + +#----------------------------------------------------------------------------- +# C++ language standard +#----------------------------------------------------------------------------- + set(MITK_CXX_STANDARD @MITK_CXX_STANDARD@) if(CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang") # CMake 3.1 does not know yet how to enable C++11 for AppleClang # See http://public.kitware.com/Bug/view.php?id=15355 set(MITK_NO_CXX_STANDARD_ERROR 1) endif() # We use target_compile_features for GNU and Clang to ensure # external projects are compiled with e.g. -std=c++11. For # msvc, C++11 support is always enabled by the compiler itself. if(NOT CMAKE_CXX_COMPILER_ID STREQUAL "GNU" AND NOT CMAKE_CXX_COMPILER_ID STREQUAL "Clang" AND NOT CMAKE_CXX_COMPILER_ID STREQUAL "MSVC") if(NOT CMAKE_CXX_STANDARD STREQUAL MITK_CXX_STANDARD AND NOT MITK_NO_CXX_STANDARD_ERROR) message(FATAL_ERROR "MITK was compiled with C++11 enabled and we can't figure out if your project is compiled with C++11 enable as well. To silence this error set CMAKE_CXX_STANDARD to \"11\" at the top of your CMakeLists.txt file or set MITK_NO_CXX_STANDARD_ERROR to TRUE.") endif() endif() +#----------------------------------------------------------------------------- +# Include required CMake scripts +#----------------------------------------------------------------------------- + # Update the CMake module path set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "@MITK_SOURCE_DIR@/CMake") -set(CppMicroServices_DIR "@CppMicroServices_DIR@") +# Standard CMake macros +include(CMakeParseArguments) +include(FeatureSummary) +include(GenerateExportHeader) +include(FindPackageHandleStandardArgs) # Include MITK macros include(MacroParseArguments) -include(GenerateExportHeader) include(mitkFunctionCheckMitkCompatibility) include(mitkFunctionOrganizeSources) include(mitkFunctionCreateWindowsBatchScript) include(mitkFunctionInstallProvisioningFiles) include(mitkFunctionInstallAutoLoadModules) include(mitkFunctionGetLibrarySearchPaths) include(mitkFunctionUseModules) include(mitkFunctionCheckModuleDependencies) include(mitkFunctionCreateModule) include(mitkMacroCreateExecutable) include(mitkMacroCreateModuleTests) include(mitkFunctionAddCustomModuleTest) include(mitkMacroMultiplexPicType) include(mitkMacroInstall) include(mitkMacroInstallHelperApp) include(mitkMacroInstallTargets) include(mitkMacroGenerateToolsLibrary) include(mitkMacroCreateCTKPlugin) include(mitkMacroGetPMDPlatformString) +include(mitkMacroFindDependency) -# Standard CMake macros -include(FeatureSummary) - -# The MITK version number -set(MITK_VERSION_MAJOR "@MITK_VERSION_MAJOR@") -set(MITK_VERSION_MINOR "@MITK_VERSION_MINOR@") -set(MITK_VERSION_PATCH "@MITK_VERSION_PATCH@") -set(MITK_VERSION_STRING "@MITK_VERSION_STRING@") +#----------------------------------------------------------------------------- +# MITK flags and directories +#----------------------------------------------------------------------------- # MITK compiler flags set(MITK_C_FLAGS "@MITK_C_FLAGS@") set(MTTK_C_FLAGS_DEBUG "@MITK_C_FLAGS_DEBUG@") set(MITK_C_FLAGS_RELEASE "@MITK_C_FLAGS_RELEASE@") set(MITK_CXX_FLAGS "@MITK_CXX_FLAGS@") set(MTTK_CXX_FLAGS_DEBUG "@MITK_CXX_FLAGS_DEBUG@") set(MITK_CXX_FLAGS_RELEASE "@MITK_CXX_FLAGS_RELEASE@") +# MITK linker flags set(MITK_EXE_LINKER_FLAGS "@MITK_EXE_LINKER_FLAGS@") set(MITK_SHARED_LINKER_FLAGS "@MITK_SHARED_LINKER_FLAGS@") set(MITK_MODULE_LINKER_FLAGS "@MITK_MODULE_LINKER_FLAGS@") -# Internal version numbers, used for approximate compatibility checks -# of a MITK development version (non-release). -set(MITK_VERSION_PLUGIN_SYSTEM 2) # dropped legacy BlueBerry plug-in CMake support - -# MITK specific variables +# MITK specific directories set(MITK_SOURCE_DIR "@MITK_SOURCE_DIR@") set(MITK_BINARY_DIR "@MITK_BINARY_DIR@") set(MITK_CMAKE_DIR "@MITK_CMAKE_DIR@") +# MITK output directories set(MITK_CMAKE_RUNTIME_OUTPUT_DIRECTORY "@MITK_CMAKE_RUNTIME_OUTPUT_DIRECTORY@") set(MITK_CMAKE_ARCHIVE_OUTPUT_DIRECTORY "@MITK_CMAKE_ARCHIVE_OUTPUT_DIRECTORY@") set(MITK_CMAKE_LIBRARY_OUTPUT_DIRECTORY "@MITK_CMAKE_LIBRARY_OUTPUT_DIRECTORY@") +#----------------------------------------------------------------------------- +# Miscellaneous variables +#----------------------------------------------------------------------------- + +# Internal version numbers, used for approximate compatibility checks +# of a MITK development version (non-release). +set(MITK_VERSION_PLUGIN_SYSTEM 2) # dropped legacy BlueBerry plug-in CMake support + set(UTILITIES_DIR "@UTILITIES_DIR@") set(REGISTER_QFUNCTIONALITY_CPP_IN "@REGISTER_QFUNCTIONALITY_CPP_IN@") set(MITK_DOXYGEN_TAGFILE_NAME "@MITK_DOXYGEN_TAGFILE_NAME@") set(MITK_LEGACY_EXPORT_MACRO_NAME 1) if(CMAKE_CURRENT_LIST_DIR STREQUAL MITK_BINARY_DIR) set(MITK_EXTERNAL_PROJECT_PREFIX @MITK_EXTERNAL_PROJECT_PREFIX@) endif() set(MITK_MODULES_PACKAGE_DEPENDS_DIR "@MITK_MODULES_PACKAGE_DEPENDS_DIR@") if(MODULES_PACKAGE_DEPENDS_DIRS) list(APPEND MODULES_PACKAGE_DEPENDS_DIRS ${MITK_MODULES_PACKAGE_DEPENDS_DIR}) list(REMOVE_DUPLICATES MODULES_PACKAGE_DEPENDS_DIRS) else() set(MODULES_PACKAGE_DEPENDS_DIRS ${MITK_MODULES_PACKAGE_DEPENDS_DIR}) endif() -# External projects -set(CTK_DIR "@CTK_DIR@") -set(ANN_DIR "@ANN_DIR@") -set(CppUnit_DIR "@CppUnit_DIR@") -set(Eigen_DIR "@Eigen_DIR@") -set(GLEW_DIR "@GLEW_DIR@") -set(tinyxml_DIR "@tinyxml_DIR@") -set(ITK_DIR "@ITK_DIR@") -set(VTK_DIR "@VTK_DIR@") -set(DCMTK_DIR "@DCMTK_DIR@") -set(GDCM_DIR "@GDCM_DIR@") -set(BOOST_ROOT "@BOOST_ROOT@") -set(OpenCV_DIR "@OpenCV_DIR@") -set(Poco_DIR "@Poco_DIR@") -set(SOFA_DIR "@SOFA_DIR@") -set(Qwt_DIR "@Qwt_DIR@") -set(ACVD_DIR "@ACVD_DIR@") -set(MITK_QMAKE_EXECUTABLE "@QT_QMAKE_EXECUTABLE@") -set(MITK_DATA_DIR "@MITK_DATA_DIR@") -set(SimpleITK_DIR "@SimpleITK_DIR@") -set(Python_DIR "@Python_DIR@") +#----------------------------------------------------------------------------- +# External dependencies +#----------------------------------------------------------------------------- -# External SDK directories -set(MITK_PMD_SDK_DIR @MITK_PMD_SDK_DIR@) +list(APPEND CMAKE_PREFIX_PATH "@MITK_EXTERNAL_PROJECT_PREFIX@") + +# ----------------------------------------- +# Qt variables and dependencies -# MITK use variables set(MITK_USE_QT @MITK_USE_QT@) set(MITK_USE_Qt4 @MITK_USE_Qt4@) set(MITK_USE_Qt5 @MITK_USE_Qt5@) -set(MITK_USE_Qwt @MITK_USE_Qwt@) + set(MITK_DESIRED_QT_VERSION @DESIRED_QT_VERSION@) -set(MITK_USE_Poco @MITK_USE_Poco@) -set(MITK_USE_BLUEBERRY @MITK_USE_BLUEBERRY@) -set(MITK_USE_SYSTEM_Boost @MITK_USE_SYSTEM_Boost@) -set(MITK_USE_Boost @MITK_USE_Boost@) -set(MITK_USE_Boost_LIBRARIES @MITK_USE_Boost_LIBRARIES@) -set(MITK_USE_CTK @MITK_USE_CTK@) -set(MITK_USE_DCMTK @MITK_USE_DCMTK@) -set(MITK_USE_OpenCV @MITK_USE_OpenCV@) -set(MITK_USE_SOFA @MITK_USE_SOFA@) + +if(MITK_USE_Qt4) + set(MITK_QT4_MINIMUM_VERSION @MITK_QT4_MINIMUM_VERSION@) + find_package(Qt4 ${MITK_QT4_MINIMUM_VERSION} REQUIRED) +elseif(MITK_USE_Qt5) + set(MITK_QT5_MINIMUM_VERSION @MITK_QT5_MINIMUM_VERSION@) + set(MITK_QT5_COMPONENTS @MITK_QT5_COMPONENTS@) + mitkMacroFindDependency(Qt5 ${MITK_QT5_MINIMUM_VERSION} COMPONENTS ${MITK_QT5_COMPONENTS}) +endif() + +# ----------------------------------------- +# Special Python variables + set(MITK_USE_Python @MITK_USE_Python@) -set(MITK_USE_SimpleITK @MITK_USE_SimpleITK@) -set(MITK_USE_ACVD @MITK_USE_ACVD@) - -# Make external targets available as imported targets to -# projects using MITK -find_package(CppMicroServices PATHS ${CppMicroServices_DIR} REQUIRED) -find_package(tinyxml PATHS ${tinyxml_DIR} REQUIRED) -find_package(GDCM PATHS ${GDCM_DIR} REQUIRED) -find_package(ITK PATHS ${ITK_DIR} REQUIRED) -find_package(VTK PATHS ${VTK_DIR} REQUIRED) -if(MITK_USE_OpenCV) - find_package(OpenCV PATHS ${OpenCV_DIR} REQUIRED) +set(MITK_USE_SYSTEM_PYTHON @MITK_USE_SYSTEM_PYTHON@) +if(MITK_USE_Python) + set(PYTHON_EXECUTABLE @PYTHON_EXECUTABLE@) + set(PYTHON_INCLUDE_DIR @PYTHON_INCLUDE_DIR@) + set(PYTHON_LIBRARY @PYTHON_LIBRARY@) + set(PYTHON_INCLUDE_DIR2 @PYTHON_INCLUDE_DIR2@) + + mitkMacroFindDependency(PythonLibs) + mitkMacroFindDependency(PythonInterp) endif() -if(MITK_USE_Poco) - find_package(Poco PATHS ${Poco_DIR} COMPONENTS Foundation Util XML JSON Zip REQUIRED) + +# ----------------------------------------- +# Special Boost variables + +set(MITK_USE_Boost @MITK_USE_Boost@) +set(MITK_USE_Boost_LIBRARIES ${MITK_USE_Boost_LIBRARIES}) +set(MITK_USE_SYSTEM_Boost @MITK_USE_SYSTEM_Boost@) +if(MITK_USE_Boost) + set(BOOST_ROOT "@BOOST_ROOT@") + set(BOOST_LIBRARYDIR "@BOOST_LIBRARYDIR@") endif() + +# ----------------------------------------- +# Special handling for SOFA + if(MITK_USE_SOFA) # The SOFAConfig.cmake file does not provide exported targets or # libraries with absolute paths, hence we need to make the link # directories globally available until the SOFAConfig.cmake file # supports a proper mechanism for handling targets. - find_package(SOFA PATHS ${SOFA_DIR} CONFIG REQUIRED) +# find_package(SOFA PATHS ${SOFA_DIR} CONFIG REQUIRED) link_directories(${SOFA_LIBRARY_DIRS}) endif() -if(MITK_USE_Qt4) - set(MITK_QT4_MINIMUM_VERSION @MITK_QT4_MINIMUM_VERSION@) - find_package(Qt4 ${MITK_QT4_MINIMUM_VERSION} REQUIRED) -elseif(MITK_USE_Qt5) - set(MITK_QT5_MINIMUM_VERSION @MITK_QT5_MINIMUM_VERSION@) - find_package(Qt5Core ${MITK_QT5_MINIMUM_VERSION} REQUIRED) -endif() -if(MITK_USE_QT) - find_package(Qwt PATHS ${Qwt_DIR} REQUIRED) +# ----------------------------------------- +# External dependencies from the superbuild +# or injected from somewhere else via +# _DIR variables. + +@MITK_CONFIG_EXTERNAL_PROJECTS@ + +# ----------------------------------------- +# Internal project dependencies + +set(CppMicroServices_DIR "@CppMicroServices_DIR@") +mitkMacroFindDependency(CppMicroServices) + +set(MITK_USE_BLUEBERRY @MITK_USE_BLUEBERRY@) +if(MITK_USE_BLUEBERRY) + + set(BlueBerry_DIR "@MITK_BINARY_DIR@/BlueBerry") + + # Don't include the BlueBerry exports file, since the targets are + # also exported in the MITK exports file + set(BB_PLUGIN_EXPORTS_FILE_INCLUDED 1) + find_package(BlueBerry) + + if(NOT BlueBerry_FOUND) + message(SEND_ERROR "MITK does not seem to be configured with BlueBerry support. Set MITK_USE_BLUEBERRY to ON in your MITK build configuration.") + endif() + + set(MITK_PLUGIN_USE_FILE "@MITK_PLUGIN_USE_FILE@") + if(MITK_PLUGIN_USE_FILE) + if(EXISTS "${MITK_PLUGIN_USE_FILE}") + include("${MITK_PLUGIN_USE_FILE}") + endif() + endif() + + set(MITK_PLUGIN_PROVISIONING_FILE "@MITK_EXTAPP_PROVISIONING_FILE@") + set(MITK_PROVISIONING_FILES + "${BLUEBERRY_PLUGIN_PROVISIONING_FILE}" + "${MITK_PLUGIN_PROVISIONING_FILE}") + endif() +#----------------------------------------------------------------------------- +# MITK sub-project variables +#----------------------------------------------------------------------------- + +# External SDK directories +set(MITK_PMD_SDK_DIR @MITK_PMD_SDK_DIR@) + # MITK ToF use variables set(MITK_TOF_PMDCAMCUBE_AVAILABLE @MITK_USE_TOF_PMDCAMCUBE@) if(MITK_TOF_PMDCAMCUBE_AVAILABLE AND NOT ${PROJECT_NAME} STREQUAL "MITK") option(MITK_USE_TOF_PMDCAMCUBE "Enable support for PMD Cam Cube" @MITK_USE_TOF_PMDCAMCUBE@) mark_as_advanced(MITK_USE_TOF_PMDCAMCUBE) endif() set(MITK_TOF_PMDCAMBOARD_AVAILABLE @MITK_USE_TOF_PMDCAMBOARD@) if(MITK_TOF_PMDCAMBOARD_AVAILABLE AND NOT ${PROJECT_NAME} STREQUAL "MITK") option(MITK_USE_TOF_PMDCAMBOARD "Enable support for PMD Cam Board" @MITK_USE_TOF_PMDCAMBOARD@) mark_as_advanced(MITK_USE_TOF_PMDCAMBOARD) endif() set(MITK_TOF_PMDO3_AVAILABLE @MITK_USE_TOF_PMDO3@) if(MITK_TOF_PMDO3_AVAILABLE AND NOT ${PROJECT_NAME} STREQUAL "MITK") option(MITK_USE_TOF_PMDO3 "Enable support for PMD =3" @MITK_USE_TOF_PMDO3@) mark_as_advanced(MITK_USE_TOF_PMDO3) endif() set(MITK_TOF_KINECT_AVAILABLE @MITK_USE_TOF_KINECT@) if(MITK_TOF_KINECT_AVAILABLE AND NOT ${PROJECT_NAME} STREQUAL "MITK") option(MITK_USE_TOF_KINECT "Enable support for Kinect" @MITK_USE_TOF_KINECT@) mark_as_advanced(MITK_USE_TOF_KINECT) endif() set(MITK_TOF_MESASR4000_AVAILABLE @MITK_USE_TOF_MESASR4000@) if(MITK_TOF_MESASR4000_AVAILABLE AND NOT ${PROJECT_NAME} STREQUAL "MITK") option(MITK_USE_TOF_MESASR4000 "Enable support for MESA SR4000" @MITK_USE_TOF_MESASR4000@) mark_as_advanced(MITK_USE_TOF_MESASR4000) endif() if(MITK_USE_IGT) #include("${MITK_DIR}/mitkIGTConfig.cmake") endif() -# Install rules for ToF libraries loaded at runtime -if(EXISTS "@MITK_BINARY_DIR@/mitkToFHardwareInstallRules.cmake") - include("@MITK_BINARY_DIR@/mitkToFHardwareInstallRules.cmake") -endif() +#----------------------------------------------------------------------------- +# Import MITK targets and set custom properties +#----------------------------------------------------------------------------- if(NOT MITK_EXPORTS_FILE_INCLUDED) if(EXISTS "@MITK_EXPORTS_FILE@") set(MITK_EXPORTS_FILE_INCLUDED 1) include("@MITK_EXPORTS_FILE@") endif() endif() -# BlueBerry support -if(MITK_USE_BLUEBERRY) - - set(BlueBerry_DIR "@MITK_BINARY_DIR@/BlueBerry") - - # Don't include the BlueBerry exports file, since the targets are - # also exported in the MITK exports file - set(BB_PLUGIN_EXPORTS_FILE_INCLUDED 1) - find_package(BlueBerry) - - if(NOT BlueBerry_FOUND) - message(SEND_ERROR "MITK does not seem to be configured with BlueBerry support. Set MITK_USE_BLUEBERRY to ON in your MITK build configuration.") - endif() - - set(MITK_PLUGIN_USE_FILE "@MITK_PLUGIN_USE_FILE@") - if(MITK_PLUGIN_USE_FILE) - if(EXISTS "${MITK_PLUGIN_USE_FILE}") - include("${MITK_PLUGIN_USE_FILE}") - endif() - endif() +# Set properties on exported targets +@MITK_EXPORTED_TARGET_PROPERTIES@ - set(MITK_PLUGIN_PROVISIONING_FILE "@MITK_EXTAPP_PROVISIONING_FILE@") - set(MITK_PROVISIONING_FILES - "${BLUEBERRY_PLUGIN_PROVISIONING_FILE}" - "${MITK_PLUGIN_PROVISIONING_FILE}") +#----------------------------------------------------------------------------- +# Install rules +#----------------------------------------------------------------------------- +# Install rules for ToF libraries loaded at runtime +if(EXISTS "@MITK_BINARY_DIR@/mitkToFHardwareInstallRules.cmake") + include("@MITK_BINARY_DIR@/mitkToFHardwareInstallRules.cmake") endif() - -# Set properties on exported targets -@MITK_EXPORTED_TARGET_PROPERTIES@ diff --git a/Modules/DataTypesExt/CMakeLists.txt b/Modules/DataTypesExt/CMakeLists.txt index 495f1e3ce3..125249ac7e 100644 --- a/Modules/DataTypesExt/CMakeLists.txt +++ b/Modules/DataTypesExt/CMakeLists.txt @@ -1,6 +1,14 @@ +set(_additional_libs) +if(USE_ITKZLIB) + list(APPEND _additional_libs itkzlib) +else() + list(APPEND _additional_libs z) +endif(USE_ITKZLIB) + MITK_CREATE_MODULE(DEPENDS MitkCore + ADDITIONAL_LIBS ${_additional_libs} WARNINGS_AS_ERRORS ) add_subdirectory(test) diff --git a/SuperBuild.cmake b/SuperBuild.cmake index 143b245059..dcf548130b 100644 --- a/SuperBuild.cmake +++ b/SuperBuild.cmake @@ -1,558 +1,442 @@ include(mitkFunctionInstallExternalCMakeProject) include(mitkFunctionCheckCompilerFlags) #----------------------------------------------------------------------------- # Convenient macro allowing to download a file #----------------------------------------------------------------------------- if(NOT MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL) set(MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL http://mitk.org/download/thirdparty) endif() 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 #----------------------------------------------------------------------------- if(UNIX AND NOT APPLE) include(mitkFunctionCheckPackageHeader) # Check for libxt-dev mitkFunctionCheckPackageHeader(StringDefs.h libxt-dev /usr/include/X11/) # Check for libtiff4-dev mitkFunctionCheckPackageHeader(tiff.h libtiff4-dev) # Check for libwrap0-dev mitkFunctionCheckPackageHeader(tcpd.h libwrap0-dev) endif() # We need a proper patch program. On Linux and MacOS, we assume # that "patch" is available. On Windows, we download patch.exe # if not patch program is found. find_program(PATCH_COMMAND patch) if((NOT PATCH_COMMAND OR NOT EXISTS ${PATCH_COMMAND}) AND WIN32) downloadFile(${MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL}/patch.exe ${CMAKE_CURRENT_BINARY_DIR}/patch.exe) find_program(PATCH_COMMAND patch ${CMAKE_CURRENT_BINARY_DIR}) endif() if(NOT PATCH_COMMAND) message(FATAL_ERROR "No patch program found.") endif() #----------------------------------------------------------------------------- # Qt options for external projects and MITK #----------------------------------------------------------------------------- if(MITK_USE_QT) set(qt_project_args -DDESIRED_QT_VERSION:STRING=${DESIRED_QT_VERSION}) else() set(qt_project_args ) endif() if(MITK_USE_Qt4) list(APPEND qt_project_args -DQT_QMAKE_EXECUTABLE:FILEPATH=${QT_QMAKE_EXECUTABLE} ) endif() #----------------------------------------------------------------------------- # ExternalProjects #----------------------------------------------------------------------------- -# These are ordered by dependencies -set(external_projects - ZLIB - Python - Numpy - tinyxml - GLUT - ANN - CppUnit - GLEW - VTK - ACVD - GDCM - OpenCV - Poco - ITK - Boost - DCMTK - CTK - SOFA - MITKData - Qwt - PCRE - Swig - SimpleITK - Eigen - raptor2 - rasqal - redland - ) - -# These are "hard" dependencies and always set to ON -set(MITK_USE_tinyxml 1) -set(MITK_USE_GLEW 1) -set(MITK_USE_GDCM 1) -set(MITK_USE_ITK 1) -set(MITK_USE_VTK 1) - -# Semi-hard dependencies, enabled by user-controlled variables -if(MITK_USE_QT) - set(MITK_USE_Qwt 1) -endif() - -if(MITK_USE_Redland) - set(MITK_USE_raptor2 1) - set(MITK_USE_PCRE 1) - set(MITK_USE_rasqal 1) - set(MITK_USE_redland 1) -endif() - -if(MITK_USE_SOFA) - set(MITK_USE_GLUT 1) -endif() - -if(MITK_USE_Python AND NOT MITK_USE_SYSTEM_PYTHON) - set(MITK_USE_ZLIB 1) -endif() - -if(MITK_USE_SimpleITK OR MITK_USE_Python) - set(MITK_USE_SWIG 1) - if(UNIX) - set(MITK_USE_PCRE 1) - endif() -endif() +get_property(external_projects GLOBAL PROPERTY MITK_EXTERNAL_PROJECTS) # A list of "nice" external projects, playing well together with CMake set(nice_external_projects ${external_projects}) -list(REMOVE_ITEM nice_external_projects Boost) +list(REMOVE_ITEM nice_external_projects Boost Python) foreach(proj ${nice_external_projects}) if(MITK_USE_${proj}) set(EXTERNAL_${proj}_DIR "${${proj}_DIR}" CACHE PATH "Path to ${proj} build directory") mark_as_advanced(EXTERNAL_${proj}_DIR) if(EXTERNAL_${proj}_DIR) set(${proj}_DIR ${EXTERNAL_${proj}_DIR}) endif() endif() endforeach() if(MITK_USE_Boost) set(EXTERNAL_BOOST_ROOT "${BOOST_ROOT}" CACHE PATH "Path to Boost directory") mark_as_advanced(EXTERNAL_BOOST_ROOT) if(EXTERNAL_BOOST_ROOT) set(BOOST_ROOT ${EXTERNAL_BOOST_ROOT}) endif() endif() # Setup file for setting custom ctest vars configure_file( CMake/SuperbuildCTestCustom.cmake.in ${MITK_BINARY_DIR}/CTestCustom.cmake @ONLY ) if(BUILD_TESTING) set(EXTERNAL_MITK_DATA_DIR "${MITK_DATA_DIR}" CACHE PATH "Path to the MITK data directory") mark_as_advanced(EXTERNAL_MITK_DATA_DIR) if(EXTERNAL_MITK_DATA_DIR) set(MITK_DATA_DIR ${EXTERNAL_MITK_DATA_DIR}) endif() endif() # Look for git early on, if needed if((BUILD_TESTING AND NOT EXTERNAL_MITK_DATA_DIR) OR (MITK_USE_CTK AND NOT EXTERNAL_CTK_DIR)) find_package(Git REQUIRED) endif() #----------------------------------------------------------------------------- # External project settings #----------------------------------------------------------------------------- include(ExternalProject) set(ep_prefix "${CMAKE_BINARY_DIR}/ep") set_property(DIRECTORY PROPERTY EP_PREFIX ${ep_prefix}) # 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(MSVC_VERSION) set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /bigobj /MP") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /bigobj /MP") endif() # This is necessary to avoid problems with compile feature checks. # CMAKE_CXX_STANDARD seems to only set the -std=c++11 flag for targets. # The CMAKE_CXX_FLAGS variable is also used for non-CMake based # external projects like Boost and PCRE. mitkFunctionCheckCompilerFlags("-std=c++11" CMAKE_CXX_FLAGS) # This is a workaround for passing linker flags # actually down to the linker invocation set(_cmake_required_flags_orig ${CMAKE_REQUIRED_FLAGS}) set(CMAKE_REQUIRED_FLAGS "-Wl,-rpath") mitkFunctionCheckCompilerFlags(${CMAKE_REQUIRED_FLAGS} _has_rpath_flag) set(CMAKE_REQUIRED_FLAGS ${_cmake_required_flags_orig}) set(_install_rpath_linkflag ) if(_has_rpath_flag) if(APPLE) set(_install_rpath_linkflag "-Wl,-rpath,@loader_path/../lib") else() set(_install_rpath_linkflag "-Wl,-rpath='$ORIGIN/../lib'") endif() endif() set(_install_rpath) if(APPLE) set(_install_rpath "@loader_path/../lib") elseif(UNIX) # this work for libraries as well as executables set(_install_rpath "\$ORIGIN/../lib") endif() set(ep_common_args -DCMAKE_CXX_EXTENSIONS:STRING=0 -DCMAKE_CXX_STANDARD:STRING=11 -DCMAKE_DEBUG_POSTFIX:STRING=d -DCMAKE_MACOSX_RPATH:BOOL=TRUE "-DCMAKE_INSTALL_RPATH:STRING=${_install_rpath}" -DBUILD_TESTING:BOOL=OFF -DCMAKE_INSTALL_PREFIX:PATH= "-DCMAKE_PREFIX_PATH:PATH=^^${CMAKE_PREFIX_PATH}" -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=${CMAKE_C_FLAGS} "-DCMAKE_CXX_FLAGS:STRING=${CMAKE_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} #link flags -DCMAKE_EXE_LINKER_FLAGS:STRING=${CMAKE_EXE_LINKER_FLAGS} -DCMAKE_SHARED_LINKER_FLAGS:STRING=${CMAKE_SHARED_LINKER_FLAGS} -DCMAKE_MODULE_LINKER_FLAGS:STRING=${CMAKE_MODULE_LINKER_FLAGS} ) # Pass the CMAKE_OSX variables to external projects if(APPLE) set(MAC_OSX_ARCHITECTURE_ARGS -DCMAKE_OSX_ARCHITECTURES:PATH=${CMAKE_OSX_ARCHITECTURES} -DCMAKE_OSX_DEPLOYMENT_TARGET:PATH=${CMAKE_OSX_DEPLOYMENT_TARGET} -DCMAKE_OSX_SYSROOT:PATH=${CMAKE_OSX_SYSROOT} ) set(ep_common_args ${MAC_OSX_ARCHITECTURE_ARGS} ${ep_common_args} ) endif() +set(mitk_superbuild_ep_args) +set(mitk_depends ) + # Include external projects +include(CMakeExternals/MITKData.cmake) foreach(p ${external_projects}) include(CMakeExternals/${p}.cmake) + + list(APPEND mitk_superbuild_ep_args + -DMITK_USE_${p}:BOOL=${MITK_USE_${p}} + ) + get_property(_package GLOBAL PROPERTY MITK_${p}_PACKAGE) + if(_package) + list(APPEND mitk_superbuild_ep_args -D${p}_DIR:PATH=${${p}_DIR}) + endif() + + list(APPEND mitk_depends ${${p}_DEPENDS}) endforeach() #----------------------------------------------------------------------------- # Set superbuild boolean args #----------------------------------------------------------------------------- set(mitk_cmake_boolean_args BUILD_SHARED_LIBS WITH_COVERAGE BUILD_TESTING - MITK_USE_QT MITK_BUILD_ALL_PLUGINS MITK_BUILD_ALL_APPS MITK_BUILD_TUTORIAL # Deprecated. Use MITK_BUILD_EXAMPLES instead MITK_BUILD_EXAMPLES - MITK_USE_ACVD - MITK_USE_ANN + MITK_USE_QT + MITK_USE_SYSTEM_Boost MITK_USE_BLUEBERRY - MITK_USE_Boost - MITK_USE_CppUnit - MITK_USE_CTK - MITK_USE_DCMTK - MITK_USE_Eigen - MITK_USE_GLEW MITK_USE_OpenCL - MITK_USE_OpenCV - MITK_USE_Poco - MITK_USE_Python - MITK_USE_Redland - MITK_USE_SOFA - MITK_USE_SYSTEM_Boost MITK_ENABLE_PIC_READER ) #----------------------------------------------------------------------------- # 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 - ${tinyxml_DEPENDS} - ${ANN_DEPENDS} - ${VTK_DEPENDS} - ${ITK_DEPENDS} - # Optionnal dependencies - ${ACVD_DEPENDS} - ${CppUnit_DEPENDS} - ${Eigen_DEPENDS} - ${GLUT_DEPENDS} - ${GLEW_DEPENDS} - ${Boost_DEPENDS} - ${CTK_DEPENDS} - ${DCMTK_DEPENDS} - ${OpenCV_DEPENDS} - ${Poco_DEPENDS} - ${PCRE_DEPENDS} - ${Swig_DEPENDS} - ${raptor2_DEPENDS} - ${rasqal_DEPENDS} - ${redland_DEPENDS} - ${SOFA_DEPENDS} - ${MITK-Data_DEPENDS} - ${Qwt_DEPENDS} - ${ZLIB_DEPENDS} - ${SimpleITK_DEPENDS} - ${Numpy_DEPENDS} + ${mitk_depends} ) #----------------------------------------------------------------------------- # Additional MITK CXX/C Flags #----------------------------------------------------------------------------- set(MITK_ADDITIONAL_C_FLAGS "" CACHE STRING "Additional C Flags for MITK") set(MITK_ADDITIONAL_C_FLAGS_RELEASE "" CACHE STRING "Additional Release C Flags for MITK") set(MITK_ADDITIONAL_C_FLAGS_DEBUG "" CACHE STRING "Additional Debug C Flags for MITK") mark_as_advanced(MITK_ADDITIONAL_C_FLAGS MITK_ADDITIONAL_C_FLAGS_DEBUG MITK_ADDITIONAL_C_FLAGS_RELEASE) set(MITK_ADDITIONAL_CXX_FLAGS "" CACHE STRING "Additional CXX Flags for MITK") set(MITK_ADDITIONAL_CXX_FLAGS_RELEASE "" CACHE STRING "Additional Release CXX Flags for MITK") set(MITK_ADDITIONAL_CXX_FLAGS_DEBUG "" CACHE STRING "Additional Debug CXX Flags for MITK") mark_as_advanced(MITK_ADDITIONAL_CXX_FLAGS MITK_ADDITIONAL_CXX_FLAGS_DEBUG MITK_ADDITIONAL_CXX_FLAGS_RELEASE) set(MITK_ADDITIONAL_EXE_LINKER_FLAGS "" CACHE STRING "Additional exe linker flags for MITK") set(MITK_ADDITIONAL_SHARED_LINKER_FLAGS "" CACHE STRING "Additional shared linker flags for MITK") set(MITK_ADDITIONAL_MODULE_LINKER_FLAGS "" CACHE STRING "Additional module linker flags for MITK") mark_as_advanced(MITK_ADDITIONAL_EXE_LINKER_FLAGS MITK_ADDITIONAL_SHARED_LINKER_FLAGS MITK_ADDITIONAL_MODULE_LINKER_FLAGS) #----------------------------------------------------------------------------- # MITK Configure #----------------------------------------------------------------------------- if(MITK_INITIAL_CACHE_FILE) set(mitk_initial_cache_arg -C "${MITK_INITIAL_CACHE_FILE}") endif() set(mitk_optional_cache_args ) foreach(type RUNTIME ARCHIVE LIBRARY) if(DEFINED CTK_PLUGIN_${type}_OUTPUT_DIRECTORY) list(APPEND mitk_optional_cache_args -DCTK_PLUGIN_${type}_OUTPUT_DIRECTORY:PATH=${CTK_PLUGIN_${type}_OUTPUT_DIRECTORY}) endif() endforeach() # Optional python variables if(MITK_USE_Python) list(APPEND mitk_optional_cache_args + -DMITK_USE_Python:BOOL=${MITK_USE_Python} -DPYTHON_EXECUTABLE:FILEPATH=${PYTHON_EXECUTABLE} -DPYTHON_INCLUDE_DIR:PATH=${PYTHON_INCLUDE_DIR} -DPYTHON_LIBRARY:FILEPATH=${PYTHON_LIBRARY} -DPYTHON_INCLUDE_DIR2:PATH=${PYTHON_INCLUDE_DIR2} -DMITK_USE_SYSTEM_PYTHON:BOOL=${MITK_USE_SYSTEM_PYTHON} ) - if( NOT MITK_USE_SYSTEM_PYTHON ) - list(APPEND mitk_optional_cache_args - # Folders are needed to create an installer - -DPython_DIR:PATH=${Python_DIR} - -DNumpy_DIR:PATH=${Numpy_DIR} - ) - endif() endif() if(MITK_USE_QT) if(DESIRED_QT_VERSION MATCHES "5") list(APPEND mitk_optional_cache_args -DQT5_INSTALL_PREFIX:PATH=${QT5_INSTALL_PREFIX} ) endif() endif() set(proj MITK-Configure) ExternalProject_Add(${proj} LIST_SEPARATOR ${sep} DOWNLOAD_COMMAND "" CMAKE_GENERATOR ${gen} CMAKE_CACHE_ARGS # --------------- Build options ---------------- -DCMAKE_INSTALL_PREFIX:PATH=${CMAKE_INSTALL_PREFIX} -DCMAKE_BUILD_TYPE:STRING=${CMAKE_BUILD_TYPE} # --------------- Compile options ---------------- -DCMAKE_C_COMPILER:FILEPATH=${CMAKE_C_COMPILER} -DCMAKE_CXX_COMPILER:FILEPATH=${CMAKE_CXX_COMPILER} "-DCMAKE_C_FLAGS:STRING=${CMAKE_C_FLAGS} ${MITK_ADDITIONAL_C_FLAGS}" "-DCMAKE_CXX_FLAGS:STRING=${CMAKE_CXX_FLAGS} ${MITK_ADDITIONAL_CXX_FLAGS}" # debug flags "-DCMAKE_CXX_FLAGS_DEBUG:STRING=${CMAKE_CXX_FLAGS_DEBUG} ${MITK_ADDITIONAL_CXX_FLAGS_DEBUG}" "-DCMAKE_C_FLAGS_DEBUG:STRING=${CMAKE_C_FLAGS_DEBUG} ${MITK_ADDITIONAL_C_FLAGS_DEBUG}" # release flags "-DCMAKE_CXX_FLAGS_RELEASE:STRING=${CMAKE_CXX_FLAGS_RELEASE} ${MITK_ADDITIONAL_CXX_FLAGS_RELEASE}" "-DCMAKE_C_FLAGS_RELEASE:STRING=${CMAKE_C_FLAGS_RELEASE} ${MITK_ADDITIONAL_C_FLAGS_RELEASE}" # relwithdebinfo -DCMAKE_CXX_FLAGS_RELWITHDEBINFO:STRING=${CMAKE_CXX_FLAGS_RELWITHDEBINFO} -DCMAKE_C_FLAGS_RELWITHDEBINFO:STRING=${CMAKE_C_FLAGS_RELWITHDEBINFO} # link flags "-DCMAKE_EXE_LINKER_FLAGS:STRING=${CMAKE_EXE_LINKER_FLAGS} ${MITK_ADDITIONAL_EXE_LINKER_FLAGS}" "-DCMAKE_SHARED_LINKER_FLAGS:STRING=${CMAKE_SHARED_LINKER_FLAGS} ${MITK_ADDITIONAL_SHARED_LINKER_FLAGS}" "-DCMAKE_MODULE_LINKER_FLAGS:STRING=${CMAKE_MODULE_LINKER_FLAGS} ${MITK_ADDITIONAL_MODULE_LINKER_FLAGS}" # Output directories -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} # ------------- Boolean build options -------------- ${mitk_superbuild_boolean_args} ${mitk_optional_cache_args} -DMITK_USE_SUPERBUILD:BOOL=OFF -DMITK_BUILD_CONFIGURATION:STRING=${MITK_BUILD_CONFIGURATION} -DCTEST_USE_LAUNCHERS:BOOL=${CTEST_USE_LAUNCHERS} # ----------------- Miscellaneous --------------- -DMITK_CTEST_SCRIPT_MODE:STRING=${MITK_CTEST_SCRIPT_MODE} -DMITK_SUPERBUILD_BINARY_DIR:PATH=${MITK_BINARY_DIR} -DMITK_MODULES_TO_BUILD:INTERNAL=${MITK_MODULES_TO_BUILD} -DMITK_WHITELIST:STRING=${MITK_WHITELIST} -DMITK_WHITELISTS_EXTERNAL_PATH:STRING=${MITK_WHITELISTS_EXTERNAL_PATH} -DMITK_WHITELISTS_INTERNAL_PATH:STRING=${MITK_WHITELISTS_INTERNAL_PATH} ${qt_project_args} -DMITK_ACCESSBYITK_INTEGRAL_PIXEL_TYPES:STRING=${MITK_ACCESSBYITK_INTEGRAL_PIXEL_TYPES} -DMITK_ACCESSBYITK_FLOATING_PIXEL_TYPES:STRING=${MITK_ACCESSBYITK_FLOATING_PIXEL_TYPES} -DMITK_ACCESSBYITK_COMPOSITE_PIXEL_TYPES:STRING=${MITK_ACCESSBYITK_COMPOSITE_PIXEL_TYPES} -DMITK_ACCESSBYITK_VECTOR_PIXEL_TYPES:STRING=${MITK_ACCESSBYITK_VECTOR_PIXEL_TYPES} -DMITK_ACCESSBYITK_DIMENSIONS:STRING=${MITK_ACCESSBYITK_DIMENSIONS} - # --------------- External project dirs --------------- + # --------------- External project options --------------- + -DMITK_DATA_DIR:PATH=${MITK_DATA_DIR} -DMITK_EXTERNAL_PROJECT_PREFIX:PATH=${ep_prefix} -DCppMicroServices_DIR:PATH=${CppMicroServices_DIR} -DMITK_KWSTYLE_EXECUTABLE:FILEPATH=${MITK_KWSTYLE_EXECUTABLE} - -DCTK_DIR:PATH=${CTK_DIR} - -DDCMTK_DIR:PATH=${DCMTK_DIR} -DDCMTK_CMAKE_DEBUG_POSTFIX:STRING=d - -DEigen_DIR:PATH=${Eigen_DIR} - -Dtinyxml_DIR:PATH=${tinyxml_DIR} - -DGLUT_DIR:PATH=${GLUT_DIR} - -DGLEW_DIR:PATH=${GLEW_DIR} - -DANN_DIR:PATH=${ANN_DIR} - -DCppUnit_DIR:PATH=${CppUnit_DIR} - -DVTK_DIR:PATH=${VTK_DIR} # FindVTK expects VTK_DIR - -DITK_DIR:PATH=${ITK_DIR} # FindITK expects ITK_DIR - -DACVD_DIR:PATH=${ACVD_DIR} - -DOpenCV_DIR:PATH=${OpenCV_DIR} - -DPoco_DIR:PATH=${Poco_DIR} - -DPCRE_DIR:PATH=${PCRE_DIR} - -DSwig_DIR:PATH=${Swig_DIR} - -DRaptor2_DIR:PATH=${raptor2_DIR} - -DRasqal_DIR:PATH=${rasqal_DIR} - -DRedland_DIR:PATH=${redland_DIR} - -DSOFA_DIR:PATH=${SOFA_DIR} - -DGDCM_DIR:PATH=${GDCM_DIR} -DBOOST_ROOT:PATH=${BOOST_ROOT} -DBOOST_LIBRARYDIR:PATH=${BOOST_LIBRARYDIR} -DMITK_USE_Boost_LIBRARIES:STRING=${MITK_USE_Boost_LIBRARIES} - -DMITK_DATA_DIR:PATH=${MITK_DATA_DIR} - -DQwt_DIR:PATH=${Qwt_DIR} - -DSimpleITK_DIR:PATH=${SimpleITK_DIR} - -DNumpy_DIR:PATH=${Numpy_DIR} CMAKE_ARGS ${mitk_initial_cache_arg} ${MAC_OSX_ARCHITECTURE_ARGS} - "-DCMAKE_PREFIX_PATH:PATH=${ep_prefix}^^${CMAKE_PREFIX_PATH}" + ${mitk_superbuild_ep_args} + "-DCMAKE_PREFIX_PATH:PATH=${ep_prefix}${sep}${CMAKE_PREFIX_PATH}" SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR} BINARY_DIR ${CMAKE_BINARY_DIR}/MITK-build BUILD_COMMAND "" INSTALL_COMMAND "" DEPENDS MITK-Utilities ) mitkFunctionInstallExternalCMakeProject(${proj}) #----------------------------------------------------------------------------- # MITK #----------------------------------------------------------------------------- if(CMAKE_GENERATOR MATCHES ".*Makefiles.*") set(mitk_build_cmd "$(MAKE)") else() set(mitk_build_cmd ${CMAKE_COMMAND} --build ${CMAKE_CURRENT_BINARY_DIR}/MITK-build --config ${CMAKE_CFG_INTDIR}) endif() if(NOT DEFINED SUPERBUILD_EXCLUDE_MITKBUILD_TARGET OR NOT SUPERBUILD_EXCLUDE_MITKBUILD_TARGET) set(MITKBUILD_TARGET_ALL_OPTION "ALL") else() set(MITKBUILD_TARGET_ALL_OPTION "") endif() add_custom_target(MITK-build ${MITKBUILD_TARGET_ALL_OPTION} COMMAND ${mitk_build_cmd} WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/MITK-build DEPENDS MITK-Configure ) #----------------------------------------------------------------------------- # Custom target allowing to drive the build of the MITK project itself #----------------------------------------------------------------------------- add_custom_target(MITK COMMAND ${mitk_build_cmd} WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/MITK-build ) diff --git a/Utilities/IpPic/CMakeLists.txt b/Utilities/IpPic/CMakeLists.txt index 49ae6864d6..735279b836 100644 --- a/Utilities/IpPic/CMakeLists.txt +++ b/Utilities/IpPic/CMakeLists.txt @@ -1,25 +1,21 @@ set(_options NO_INIT GCC_DEFAULT_VISIBILITY) if(MITK_WIN32_FORCE_STATIC) list(APPEND _options FORCE_STATIC) endif() set(_additional_libs) if(USE_ITKZLIB) - if(TARGET itksys) - set(ITK_TARGETS_IMPORTED 1) - endif() - find_package(ITK REQUIRED) list(APPEND _additional_libs itkzlib) else() list(APPEND _additional_libs z) endif(USE_ITKZLIB) mitk_create_module( ADDITIONAL_LIBS ${_additional_libs} ${_options} C_MODULE ) target_compile_definitions(${MODULE_TARGET} PRIVATE -DMITK_IPPIC_COMPILE)