Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
Fetching contributors…

Cannot retrieve contributors at this time

898 lines (765 sloc) 41.217 kb
# This is the root ITK CMakeLists file.
CMAKE_MINIMUM_REQUIRED(VERSION 2.4)
IF(COMMAND CMAKE_POLICY)
CMAKE_POLICY(SET CMP0003 NEW)
ENDIF(COMMAND CMAKE_POLICY)
PROJECT(ITK)
INCLUDE_REGULAR_EXPRESSION("^([Nn]rrd|itk|vtk|vnl|vcl|vxl|v3p|f2c|netlib|ce|itpack|DICOM|meta|png|dbh|tif|jpeg|zlib|gdcm).*$")
SOURCE_GROUP("XML Files" REGULAR_EXPRESSION "[.]xml$")
# On Visual Studio 8 MS deprecated C. This removes all 1.276E1265 security
# warnings
IF(WIN32)
IF(NOT BORLAND)
IF(NOT CYGWIN)
IF(NOT MINGW)
IF(NOT ITK_ENABLE_VISUAL_STUDIO_DEPRECATED_C_WARNINGS)
ADD_DEFINITIONS(
-D_CRT_FAR_MAPPINGS_NO_DEPRECATE
-D_CRT_IS_WCTYPE_NO_DEPRECATE
-D_CRT_MANAGED_FP_NO_DEPRECATE
-D_CRT_NONSTDC_NO_DEPRECATE
-D_CRT_SECURE_NO_DEPRECATE
-D_CRT_SECURE_NO_DEPRECATE_GLOBALS
-D_CRT_SETERRORMODE_BEEP_SLEEP_NO_DEPRECATE
-D_CRT_TIME_FUNCTIONS_NO_DEPRECATE
-D_CRT_VCCLRIT_NO_DEPRECATE
-D_SCL_SECURE_NO_DEPRECATE
)
ENDIF(NOT ITK_ENABLE_VISUAL_STUDIO_DEPRECATED_C_WARNINGS)
ENDIF(NOT MINGW)
ENDIF(NOT CYGWIN)
ENDIF(NOT BORLAND)
ENDIF(WIN32)
# If CMake is the version we're expecting, don't show the
# CMAKE_BACKWARDS_COMPATIBILITY option. If the version is higher than the
# minimal version required, then show the backward compatibility option.
IF("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" MATCHES "^2\\.4$")
MARK_AS_ADVANCED(FORCE CMAKE_BACKWARDS_COMPATIBILITY)
ELSE("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" MATCHES "^2\\.4$")
MARK_AS_ADVANCED(CLEAR CMAKE_BACKWARDS_COMPATIBILITY)
ENDIF("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" MATCHES "^2\\.4$")
#-----------------------------------------------------------------------------
# ITK version number. An even minor number corresponds to releases.
SET(ITK_VERSION_MAJOR "3")
SET(ITK_VERSION_MINOR "20")
SET(ITK_VERSION_PATCH "0")
# Version string should not include patch level. The major.minor is
# enough to distinguish available features of the toolkit.
SET(ITK_VERSION_STRING "${ITK_VERSION_MAJOR}.${ITK_VERSION_MINOR}")
#-----------------------------------------------------------------------------
# Load some macros.
INCLUDE(${ITK_SOURCE_DIR}/Utilities/itkThirdParty.cmake)
#-----------------------------------------------------------------------------
# Test for some required system information.
INCLUDE (${CMAKE_ROOT}/Modules/CMakeBackwardCompatibilityC.cmake)
INCLUDE (${CMAKE_ROOT}/Modules/CMakeBackwardCompatibilityCXX.cmake)
#-----------------------------------------------------------------------------
# Configure Dart testing support. This should be done before any
# MESSAGE(FATAL_ERROR ...) commands are invoked.
INCLUDE(${CMAKE_ROOT}/Modules/Dart.cmake)
FIND_PACKAGE(Tclsh)
MARK_AS_ADVANCED(TCL_TCLSH DART_ROOT)
ENABLE_TESTING()
IF(BUILD_TESTING)
CONFIGURE_FILE(${ITK_SOURCE_DIR}/CMake/RemoveTemporaryFiles.cmake.in
${ITK_BINARY_DIR}/CMake/RemoveTemporaryFiles.cmake @ONLY IMMEDIATE)
CONFIGURE_FILE(${ITK_SOURCE_DIR}/CMake/itkSampleBuildTest.cmake.in
${ITK_BINARY_DIR}/CMake/itkSampleBuildTest.cmake @ONLY)
CONFIGURE_FILE(${ITK_SOURCE_DIR}/CMake/CTestCustom.ctest.in
${ITK_BINARY_DIR}/CMake/CTestCustom.ctest @ONLY)
CONFIGURE_FILE(${ITK_SOURCE_DIR}/CMake/CTestCustom.ctest.in
${ITK_BINARY_DIR}/Testing/Code/Common/CTestCustom.ctest @ONLY)
FILE(WRITE ${ITK_BINARY_DIR}/CTestCustom.cmake
"INCLUDE(\"${ITK_BINARY_DIR}/CMake/CTestCustom.ctest\")\n")
CONFIGURE_FILE(${ITK_SOURCE_DIR}/InsightLogo.gif
${ITK_BINARY_DIR}/Testing/HTML/TestingResults/Icons/Logo.gif
COPYONLY IMMEDIATE)
SET(BUILDNAME "${BUILDNAME}" CACHE STRING "Name of build on the dashboard")
MARK_AS_ADVANCED(BUILDNAME)
ENDIF(BUILD_TESTING)
#-----------------------------------------------------------------------------
# Output directories.
IF(NOT LIBRARY_OUTPUT_PATH)
SET (LIBRARY_OUTPUT_PATH ${ITK_BINARY_DIR}/bin CACHE INTERNAL "Single output directory for building all libraries.")
ENDIF(NOT LIBRARY_OUTPUT_PATH)
IF(NOT EXECUTABLE_OUTPUT_PATH)
SET (EXECUTABLE_OUTPUT_PATH ${ITK_BINARY_DIR}/bin CACHE INTERNAL "Single output directory for building all executables.")
ENDIF(NOT EXECUTABLE_OUTPUT_PATH)
MARK_AS_ADVANCED(LIBRARY_OUTPUT_PATH EXECUTABLE_OUTPUT_PATH)
SET(ITK_LIBRARY_PATH "${LIBRARY_OUTPUT_PATH}")
SET(ITK_EXECUTABLE_PATH "${EXECUTABLE_OUTPUT_PATH}")
SET(CXX_TEST_PATH ${EXECUTABLE_OUTPUT_PATH})
SET(CMAKE_MODULE_PATH ${ITK_SOURCE_DIR}/CMake)
# Deal with FFT v3 Options
MARK_AS_ADVANCED(USE_FFTWD)
OPTION(USE_FFTWD "Use double precision FFTW if found" OFF)
MARK_AS_ADVANCED(USE_FFTWF)
OPTION(USE_FFTWF "Use single precision FFTW if found" OFF)
IF( USE_FFTWD OR USE_FFTWF )
SET(msg "ATTENTION: You have enabled the use of FFTW,")
SET(msg "${msg} this library is distributed under a GPL license.")
SET(msg "${msg} By enabling this option, the binary of the ITK libraries")
SET(msg "${msg} that you are going to build will be covered by a GPL license,")
SET(msg "${msg} and so it will be any executable that you link against these libraries.")
MESSAGE("${msg}")
FIND_PACKAGE( FFTW )
ENDIF( USE_FFTWD OR USE_FFTWF )
# Deal with SGI SCSL Options
OPTION(USE_SCSL "Use the SGI SCSL High Performance Computing math library" OFF)
MARK_AS_ADVANCED(USE_SCSL)
IF( USE_SCSL )
FIND_PACKAGE( SCSL )
ENDIF( USE_SCSL )
# Deal with MINC2 options
MARK_AS_ADVANCED(ITK_USE_MINC2)
OPTION(ITK_USE_MINC2 "Use MINC2 File Format" OFF)
IF( ITK_USE_MINC2 )
FIND_PACKAGE( MINC2 )
IF( NOT MINC2_FOUND )
MESSAGE("You requested to use MINC2 but some components are missing")
ENDIF( NOT MINC2_FOUND )
ENDIF( ITK_USE_MINC2 )
#-----------------------------------------------------------------------------
# ITK build configuration options.
OPTION(BUILD_SHARED_LIBS "Build ITK with shared libraries." OFF)
SET(ITK_BUILD_SHARED_LIBS ${BUILD_SHARED_LIBS})
IF(NOT ITK_NO_LIBRARY_VERSION)
# This setting of SOVERSION assumes that any API change
# will increment either the minor or major version number of ITK.
SET(ITK_LIBRARY_PROPERTIES
VERSION "${ITK_VERSION_MAJOR}.${ITK_VERSION_MINOR}.${ITK_VERSION_PATCH}"
SOVERSION "${ITK_VERSION_MAJOR}.${ITK_VERSION_MINOR}"
)
ENDIF(NOT ITK_NO_LIBRARY_VERSION)
#-----------------------------------------------------------------------------
# Provide compatibility options.
OPTION(ITK_LEGACY_REMOVE "Remove all legacy code completely." OFF)
OPTION(ITK_LEGACY_SILENT "Silence all legacy code messages." OFF)
MARK_AS_ADVANCED(ITK_LEGACY_REMOVE ITK_LEGACY_SILENT)
SET(GDCM_LEGACY_SILENT ${ITK_LEGACY_SILENT})
#-----------------------------------------------------------------------------
# ITK build patented algorithms
OPTION(ITK_USE_PATENTED "Build algorithms that are covered with Patents. It is YOUR responsibility to obtain a license from the patent holder in order to use these methods." OFF)
MARK_AS_ADVANCED(ITK_USE_PATENTED)
#-----------------------------------------------------------------------------
# ITK build classes that are in the review process
OPTION(ITK_USE_REVIEW "Build algorithms that are candidates to be included in the Toolkit. This classes are not covered by the Backward Compatibility Policy, nor the Copyright Policy of ITK." OFF)
MARK_AS_ADVANCED(ITK_USE_REVIEW)
#-----------------------------------------------------------------------------
# ITK uses KWStyle for checking the coding style
INCLUDE(${ITK_SOURCE_DIR}/Utilities/KWStyle/KWStyle.cmake)
#-----------------------------------------------------------------------------
# ITK turn on concept checking
IF( NOT BORLAND )
OPTION(ITK_USE_CONCEPT_CHECKING "Turn on concept checking to give helpful errors at compile time if a type cannot be used as a template parameter." ON)
MARK_AS_ADVANCED(ITK_USE_CONCEPT_CHECKING)
OPTION(ITK_USE_STRICT_CONCEPT_CHECKING "Turn on Strict concept checking to give more stringent errors at compile time if a type cannot be used as a template parameter." OFF)
MARK_AS_ADVANCED(ITK_USE_STRICT_CONCEPT_CHECKING)
ELSE( NOT BORLAND )
SET(ITK_USE_CONCEPT_CHECKING OFF)
MARK_AS_ADVANCED(ITK_USE_CONCEPT_CHECKING)
SET(ITK_USE_STRICT_CONCEPT_CHECKING OFF)
MARK_AS_ADVANCED(ITK_USE_STRICT_CONCEPT_CHECKING)
ENDIF( NOT BORLAND )
#-----------------------------------------------------------------------------
# Make the itk::Image assume the behavior of the itk::OrientedImage
MARK_AS_ADVANCED(ITK_IMAGE_BEHAVES_AS_ORIENTED_IMAGE)
OPTION(ITK_IMAGE_BEHAVES_AS_ORIENTED_IMAGE "Makes itk::Image behave like itk::OrientedImage" ON)
# ITK turn on experimental version of accelerated image registration
OPTION(ITK_USE_OPTIMIZED_REGISTRATION_METHODS "Turn on the experimental version of accelerated registration methods." OFF)
MARK_AS_ADVANCED(ITK_USE_OPTIMIZED_REGISTRATION_METHODS)
IF(ITK_USE_OPTIMIZED_REGISTRATION_METHODS)
IF(NOT ITK_USE_REVIEW)
MESSAGE(FATAL_ERROR "ITK_USE_REVIEW is currently OFF but it should be ON if you want to use the experimental optimized registration methods.")
ENDIF(NOT ITK_USE_REVIEW)
# Warn the user about the implications of turning optimized registration methods ON
SET(msg "Attention: You have chosen to enable the use of Optimized Registration Methods.")
SET(msg "${msg} These methods add multi-threading capabilities to several image metrics")
SET(msg "${msg} as well as some Transforms and Interpolators. In order to take full advantage")
SET(msg "${msg} of these new features you will have to also add some new calls to these components.")
SET(msg "${msg} Please look at the files in the Examples/Review directory for further details.")
# display the message during the setup
MESSAGE("${msg}")
ENDIF(ITK_USE_OPTIMIZED_REGISTRATION_METHODS)
#-----------------------------------------------------------------------------
# ITK use the new statistics framework
OPTION( ITK_USE_REVIEW_STATISTICS "Use the experimental statistics framework." OFF)
MARK_AS_ADVANCED( ITK_USE_REVIEW_STATISTICS )
IF(ITK_USE_REVIEW_STATISTICS)
IF(NOT ITK_USE_REVIEW)
MESSAGE(FATAL_ERROR "ITK_USE_REVIEW is currently OFF but it should be ON if you want to use the experimental statistics framework.")
ENDIF(NOT ITK_USE_REVIEW)
# Warn the user about the implications of using the new statistics framework.
SET(msg "Attention: You have chosen to use the new statistics framework instead of the existing framework.")
SET(msg "${msg} The statistics classes have been re-designed/refactored and in several")
SET(msg "${msg} cases do not conform to the API of the older framework. You may need to")
SET(msg "${msg} change your code to use the new API.")
MESSAGE("${msg}")
ENDIF(ITK_USE_REVIEW_STATISTICS)
#-----------------------------------------------------------------------------
# ITK turn on experimental version of accelerated image registration
OPTION(ITK_USE_CONSOLIDATED_MORPHOLOGY "Turn on the experimental consolidated morphology." OFF)
MARK_AS_ADVANCED(ITK_USE_CONSOLIDATED_MORPHOLOGY)
IF(ITK_USE_CONSOLIDATED_MORPHOLOGY)
IF(NOT ITK_USE_REVIEW)
MESSAGE(FATAL_ERROR "ITK_USE_REVIEW is currently OFF but it should be ON if you want to use the experimental consolidated morphology.")
ENDIF(NOT ITK_USE_REVIEW)
# Warn the user about the implications of turning consolidated morphology ON
SET(msg "Attention: You have chosen to enable the use of consolidated morphology.")
# TODO: warn more than that
# display the message during the setup
MESSAGE("${msg}")
ENDIF(ITK_USE_CONSOLIDATED_MORPHOLOGY)
#-----------------------------------------------------------------------------
# ITK turn on the use of experimental IO factories for the TransformFileReader and TransformFileWriter
OPTION(ITK_USE_TRANSFORM_IO_FACTORIES "Turn on the experimental IO factories for reading and writing transforms." OFF)
MARK_AS_ADVANCED(ITK_USE_TRANSFORM_IO_FACTORIES)
IF(ITK_USE_TRANSFORM_IO_FACTORIES)
IF(NOT ITK_USE_REVIEW)
MESSAGE(FATAL_ERROR "ITK_USE_REVIEW is currently OFF but it should be ON if you want to use the experimental transform IO factories.")
ENDIF(NOT ITK_USE_REVIEW)
ENDIF(ITK_USE_TRANSFORM_IO_FACTORIES)
#-----------------------------------------------------------------------------
# ITK turn on the correct usage of oriented images in gradient computations and image registration.
OPTION(ITK_USE_ORIENTED_IMAGE_DIRECTION "Turn on correct use of oriented images direction in gradient computation and image registration." ON)
MARK_AS_ADVANCED(ITK_USE_ORIENTED_IMAGE_DIRECTION)
#-----------------------------------------------------------------------------
# ITK turn on the correct usage of centered-pixel coordinates.
OPTION(ITK_USE_CENTERED_PIXEL_COORDINATES_CONSISTENTLY "Turn on correct usage of centered-pixel coordinates." ON)
MARK_AS_ADVANCED(ITK_USE_CENTERED_PIXEL_COORDINATES_CONSISTENTLY)
#-----------------------------------------------------------------------------
# ITK turn on the correct usage of centered-pixel coordinates.
OPTION(ITK_USE_REGION_VALIDATION_IN_ITERATORS "Turn on region validation in Iterator constructors." ON)
MARK_AS_ADVANCED(ITK_USE_REGION_VALIDATION_IN_ITERATORS)
#-----------------------------------------------------------------------------
# ITK turn on the use of Template Meta Programming techniques for unrolling loops of array-like operations
OPTION(ITK_USE_TEMPLATE_META_PROGRAMMING_LOOP_UNROLLING "Turn on the use of Template Meta-Programming techniques for unrolling for-loops at compile time." ON)
MARK_AS_ADVANCED(ITK_USE_TEMPLATE_META_PROGRAMMING_LOOP_UNROLLING)
OPTION(ITK_USE_DEPRECATED_LEVELSET_INTERPOLATION "Turn on the use of a sparse field level set surface interpolation method that has been deprecated since ITK 3.6. Turn this flag ON to exactly replicate the behavior of ITK<=3.4." OFF)
MARK_AS_ADVANCED(ITK_USE_DEPRECATED_LEVELSET_INTERPOLATION)
OPTION(ITK_USE_DEPRECATED_FAST_MARCHING "Turn on incorrect handling of TrialPoints in itk::FastMarchingImageFilter result of a bug fixed in ITK 3.18. Turn this flag ON to exactly replicate the behavior of ITK<=3.16." OFF)
MARK_AS_ADVANCED(ITK_USE_DEPRECATED_FAST_MARCHING)
#-----------------------------------------------------------------------------
# Installation vars.
# ITK_INSTALL_BIN_DIR - binary dir (executables)
# ITK_INSTALL_LIB_DIR - library dir (libs)
# ITK_INSTALL_DATA_DIR - share dir (say, examples, data, etc)
# ITK_INSTALL_INCLUDE_DIR - include dir (headers)
# ITK_INSTALL_PACKAGE_DIR - package/export configuration files
# ITK_INSTALL_NO_DEVELOPMENT - do not install development files
# ITK_INSTALL_NO_RUNTIME - do not install runtime files
# ITK_INSTALL_NO_DOCUMENTATION - do not install documentation files
OPTION(ITK_USE_FLAT_DIRECTORY_INSTALL "When ON, ITK will install all the header files in a single directory. This reduces the number of directories that must be searched for headers in projects based on ITK" OFF)
MARK_AS_ADVANCED(ITK_USE_FLAT_DIRECTORY_INSTALL)
IF(NOT ITK_INSTALL_BIN_DIR)
# Solaris: unlike libraries, 64 bit executables should be installed in "bin${sun64}" only
# if the 32 version is installed in "bin/sparcv7" or "bin/i86", and a isaexec
# is copied in "bin" with the name of the executable, so the system can choose the best
# executable. If only a 32 or 64 bit version is available, the executable should go in
# bin. So it seems better to let the packagers deal with that.
# Ref: http://docs.sun.com/app/docs/doc/816-5138/dev-env-13?a=view
SET(ITK_INSTALL_BIN_DIR "/bin")
ENDIF(NOT ITK_INSTALL_BIN_DIR)
IF(NOT ITK_INSTALL_LIB_DIR)
# 64 bit libraries are not installed in the same directories on solaris
# Ref: http://docs.sun.com/app/docs/doc/816-5138/6mba6ua5m?a=view
SET(sun64 )
IF(CMAKE_SYSTEM MATCHES "SunOS.*" AND CMAKE_SIZEOF_VOID_P EQUAL 8)
EXEC_PROGRAM("uname"
ARGS "-p"
OUTPUT_VARIABLE sunproc
)
IF("${sunproc}" STREQUAL "sparc")
SET(sun64 "/sparcv9")
ENDIF("${sunproc}" STREQUAL "sparc")
IF("${sunproc}" STREQUAL "i386")
SET(sun64 "/amd64")
ENDIF("${sunproc}" STREQUAL "i386")
IF("${sun64}" STREQUAL "")
# sun64 is not set - solaris has been ported to a new architecture?
MESSAGE("Warning: Unknown processor '${sunproc}'. The libraries may not be installed in the right place.")
ENDIF("${sun64}" STREQUAL "")
ENDIF(CMAKE_SYSTEM MATCHES "SunOS.*" AND CMAKE_SIZEOF_VOID_P EQUAL 8)
SET(ITK_INSTALL_LIB_DIR "/lib/InsightToolkit${sun64}")
ENDIF(NOT ITK_INSTALL_LIB_DIR)
IF(NOT ITK_INSTALL_DATA_DIR)
SET(ITK_INSTALL_DATA_DIR "/share/InsightToolkit")
ENDIF(NOT ITK_INSTALL_DATA_DIR)
IF(NOT ITK_INSTALL_INCLUDE_DIR)
SET(ITK_INSTALL_INCLUDE_DIR "/include/InsightToolkit")
ENDIF(NOT ITK_INSTALL_INCLUDE_DIR)
IF(NOT ITK_INSTALL_PACKAGE_DIR)
SET(ITK_INSTALL_PACKAGE_DIR ${ITK_INSTALL_LIB_DIR}
CACHE INTERNAL "")
ENDIF(NOT ITK_INSTALL_PACKAGE_DIR)
IF(NOT ITK_INSTALL_NO_DEVELOPMENT)
SET(ITK_INSTALL_NO_DEVELOPMENT 0)
ENDIF(NOT ITK_INSTALL_NO_DEVELOPMENT)
IF(NOT ITK_INSTALL_NO_RUNTIME)
SET(ITK_INSTALL_NO_RUNTIME 0)
ENDIF(NOT ITK_INSTALL_NO_RUNTIME)
IF(NOT ITK_INSTALL_NO_DOCUMENTATION)
SET(ITK_INSTALL_NO_DOCUMENTATION 0)
ENDIF(NOT ITK_INSTALL_NO_DOCUMENTATION)
SET(ITK_INSTALL_NO_LIBRARIES)
IF(ITK_BUILD_SHARED_LIBS)
IF(ITK_INSTALL_NO_RUNTIME AND ITK_INSTALL_NO_DEVELOPMENT)
SET(ITK_INSTALL_NO_LIBRARIES 1)
ENDIF(ITK_INSTALL_NO_RUNTIME AND ITK_INSTALL_NO_DEVELOPMENT)
ELSE(ITK_BUILD_SHARED_LIBS)
IF(ITK_INSTALL_NO_DEVELOPMENT)
SET(ITK_INSTALL_NO_LIBRARIES 1)
ENDIF(ITK_INSTALL_NO_DEVELOPMENT)
ENDIF(ITK_BUILD_SHARED_LIBS)
# Because INSTALL_* commands require a leading / and because INSTALL (cmake 2.4
# and newer) requires no leading / to install under INSTALL_PREFIX, we
# are stripping the leading /. In the future, there should be no leading
# / in any install directory variables
STRING(REGEX REPLACE "^/" "" ITK_INSTALL_LIB_DIR_CM24 "${ITK_INSTALL_LIB_DIR}")
STRING(REGEX REPLACE "^/" "" ITK_INSTALL_BIN_DIR_CM24 "${ITK_INSTALL_BIN_DIR}")
STRING(REGEX REPLACE "^/" "" ITK_INSTALL_INCLUDE_DIR_CM24 "${ITK_INSTALL_INCLUDE_DIR}")
STRING(REGEX REPLACE "^/" "" ITK_INSTALL_PACKAGE_DIR_CM24 "${ITK_INSTALL_PACKAGE_DIR}")
STRING(REGEX REPLACE "^/" "" ITK_INSTALL_DOXYGEN_DIR_CM24 "${ITK_INSTALL_DOXYGEN_DIR}")
STRING(REGEX REPLACE "^/" "" ITK_INSTALL_TCL_DIR_CM24 "${ITK_INSTALL_TCL_DIR}")
STRING(REGEX REPLACE "^/" "" ITK_INSTALL_JAVA_DIR_CM24 "${ITK_INSTALL_JAVA_DIR}")
# Make sure the user does not try to install on top of the build tree.
IF(WIN32 OR APPLE OR UNIX)
STRING(TOLOWER "${CMAKE_INSTALL_PREFIX}" _PREFIX)
STRING(TOLOWER "${ITK_BINARY_DIR}" _BUILD)
ELSE(WIN32 OR APPLE OR UNIX)
SET(_PREFIX "${CMAKE_INSTALL_PREFIX}")
SET(_BUILD "${ITK_BINARY_DIR}")
ENDIF(WIN32 OR APPLE OR UNIX)
IF("${_PREFIX}" STREQUAL "${_BUILD}")
MESSAGE(FATAL_ERROR
"The current CMAKE_INSTALL_PREFIX points at the build tree:\n"
" ${CMAKE_INSTALL_PREFIX}\n"
"This is not supported."
)
ENDIF("${_PREFIX}" STREQUAL "${_BUILD}")
# set ITK_DIR so it can be used by subprojects
SET(ITK_DIR "${CMAKE_BINARY_DIR}" CACHE INTERNAL "ITK dir to be used by subprojects")
#-----------------------------------------------------------------------------
# Set up CPack support, to be able to distribute ITK binary packages. It will
# be particulary useful to distributed prebuilt ITK witk extended languages
# support enable
#
INCLUDE(InstallRequiredSystemLibraries)
SET(CPACK_PACKAGE_DESCRIPTION_SUMMARY "Insight Toolkit")
SET(CPACK_PACKAGE_VENDOR "ISC")
SET(CPACK_PACKAGE_VERSION_MAJOR "${ITK_VERSION_MAJOR}")
SET(CPACK_PACKAGE_VERSION_MINOR "${ITK_VERSION_MINOR}")
SET(CPACK_PACKAGE_VERSION_PATCH "${ITK_VERSION_PATCH}")
SET(CPACK_PACKAGE_INSTALL_DIRECTORY "InsightToolkit-${ITK_VERSION_MAJOR}.${ITK_VERSION_MINOR}")
# SET(CPACK_PACKAGE_DESCRIPTION_FILE "${CMAKE_CURRENT_SOURCE_DIR}/README")
SET(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_CURRENT_SOURCE_DIR}/Copyright/ITKCopyright.txt")
INCLUDE(CPack)
#-----------------------------------------------------------------------------
# Perform a setup of ITK Wrapping. This will provide CMake options for
# individual wrapping as well as determine if CableSwig is required. If it is,
# ITK_NEED_CableSwig will be set. This file also tries to locate CableSwig by
# searching first in the source tree of ITK, and if that fails, it searches
# for a binary built of CableSwig.
#
INCLUDE(${ITK_SOURCE_DIR}/Wrapping/itkWrapSetup.cmake)
IF(WIN32)
# Some libraries (e.g. vxl libs) have no dllexport markup, so we can
# build full shared libraries only with the GNU toolchain.
IF(CMAKE_COMPILER_IS_GNUCXX)
# CMake adds --enable-all-exports on Cygwin (since Cygwin is
# supposed to be UNIX-like), but we need to add it explicitly for
# a native windows build with the MinGW tools.
IF(MINGW)
SET(CMAKE_SHARED_LIBRARY_CREATE_C_FLAGS
"-shared -Wl,--export-all-symbols -Wl,--enable-auto-import")
SET(CMAKE_SHARED_LIBRARY_CREATE_CXX_FLAGS
"-shared -Wl,--export-all-symbols -Wl,--enable-auto-import")
SET(CMAKE_EXE_LINKER_FLAGS "-Wl,--enable-auto-import")
ENDIF(MINGW)
IF(CYGWIN)
SET(CMAKE_EXE_LINKER_FLAGS "-Wl,--enable-auto-import")
ENDIF(CYGWIN)
ELSE(CMAKE_COMPILER_IS_GNUCXX)
IF(BUILD_SHARED_LIBS)
SET(ITK_COMMON_BUILD_TYPE "SHARED")
ELSE(BUILD_SHARED_LIBS)
SET(ITK_COMMON_BUILD_TYPE "STATIC")
ENDIF(BUILD_SHARED_LIBS)
SET(BUILD_SHARED_LIBS OFF)
ENDIF(CMAKE_COMPILER_IS_GNUCXX)
ENDIF(WIN32)
OPTION(BUILD_EXAMPLES "Build the Examples directory." ON)
OPTION(ITK_USE_SYSTEM_VXL "Use an outside build of VXL." OFF)
MARK_AS_ADVANCED(ITK_USE_SYSTEM_VXL)
IF(ITK_USE_SYSTEM_VXL)
FIND_PACKAGE(VXL)
IF(VXL_FOUND)
INCLUDE(${VXL_CMAKE_DIR}/UseVXL.cmake)
SET(VXL_NUMERICS_LIBRARIES vnl vnl_algo netlib vcl)
ELSE(VXL_FOUND)
MESSAGE(FATAL_ERROR "Must set VXL_DIR for ITK_USE_SYSTEM_VXL.")
ENDIF(VXL_FOUND)
ELSE(ITK_USE_SYSTEM_VXL)
SET(VXL_NETLIB_INCLUDE_DIR ${ITK_SOURCE_DIR}/Utilities/vxl/v3p/netlib)
SET(VXL_NUMERICS_LIBRARIES itkvnl_algo)
ENDIF(ITK_USE_SYSTEM_VXL)
# Provide options to use system versions of third-party libraries.
ITK_THIRD_PARTY_OPTION(ZLIB zlib)
ITK_THIRD_PARTY_OPTION(PNG png)
ITK_THIRD_PARTY_OPTION(TIFF tiff)
OPTION(ITK_USE_LIBXML2 "Use LIBXML2." OFF)
MARK_AS_ADVANCED(ITK_USE_LIBXML2)
ITK_THIRD_PARTY_OPTION(LIBXML2 libxml2)
#-----------------------------------------------------------------------------
# If choose to build documentation, then search for Doxygen executables.
OPTION(BUILD_DOXYGEN "Build Doxygen Documentation" OFF)
IF(BUILD_DOXYGEN)
FIND_PACKAGE(Doxygen)
ENDIF(BUILD_DOXYGEN)
#-----------------------------------------------------------------------------
# Dispatch the build into the proper subdirectories.
SUBDIRS(Utilities Code)
SUBDIRS(Wrapping)
IF (BUILD_TESTING)
SUBDIRS(Testing)
ENDIF (BUILD_TESTING)
IF(BUILD_EXAMPLES)
SUBDIRS(Examples)
ENDIF(BUILD_EXAMPLES)
#-----------------------------------------------------------------------------
# ITK requires special compiler flags on some platforms.
IF(CMAKE_COMPILER_IS_GNUCXX)
SET(ITK_REQUIRED_C_FLAGS "${ITK_REQUIRED_C_FLAGS} -Wall -Wno-uninitialized -Wno-unused-parameter")
SET(ITK_REQUIRED_CXX_FLAGS "${ITK_REQUIRED_CXX_FLAGS} -ftemplate-depth-50 -Wall")
INCLUDE(${ITK_SOURCE_DIR}/CMake/itkCheckCXXAcceptsFlags.cmake)
itkCHECK_CXX_ACCEPTS_FLAGS("-Wno-deprecated" CXX_HAS_DEPRECATED_FLAG)
IF(CXX_HAS_DEPRECATED_FLAG)
SET(ITK_REQUIRED_CXX_FLAGS "${ITK_REQUIRED_CXX_FLAGS} -Wno-deprecated")
ENDIF(CXX_HAS_DEPRECATED_FLAG)
IF(APPLE)
# -no-cpp-precomp and -Wno-long-double were compiler flags present
# only in Apple's gcc and not in the FSF gcc. The flags are obsolete
# and totally removed in gcc 4.2 and later. I believe they are only
# needed with gcc 3.3 and earlier.
itkCHECK_CXX_ACCEPTS_FLAGS("-no-cpp-precomp" CXX_HAS_CPP_PRECOMP_FLAG)
IF(CXX_HAS_CPP_PRECOMP_FLAG)
SET(ITK_REQUIRED_C_FLAGS "${ITK_REQUIRED_C_FLAGS} -no-cpp-precomp")
SET(ITK_REQUIRED_CXX_FLAGS "${ITK_REQUIRED_CXX_FLAGS} -no-cpp-precomp")
ENDIF(CXX_HAS_CPP_PRECOMP_FLAG)
itkCHECK_CXX_ACCEPTS_FLAGS("-Wno-long-double" CXX_HAS_LONGDOUBLE_FLAG)
IF(CXX_HAS_LONGDOUBLE_FLAG)
SET(ITK_REQUIRED_C_FLAGS "${ITK_REQUIRED_C_FLAGS} -Wno-long-double")
SET(ITK_REQUIRED_CXX_FLAGS "${ITK_REQUIRED_CXX_FLAGS} -Wno-long-double")
ENDIF(CXX_HAS_LONGDOUBLE_FLAG)
OPTION(ITK_USE_64BITS_APPLE_TRUNCATION_WARNING "Turn on warnings on 64bits to 32bits truncations." OFF)
MARK_AS_ADVANCED(ITK_USE_64BITS_APPLE_TRUNCATION_WARNING)
ENDIF(APPLE)
# gcc must have -msse2 option to enable sse2 support
IF(VNL_CONFIG_ENABLE_SSE2 OR VNL_CONFIG_ENABLE_SSE2_ROUNDING)
SET(ITK_REQUIRED_CXX_FLAGS "${ITK_REQUIRED_CXX_FLAGS} -msse2")
ENDIF(VNL_CONFIG_ENABLE_SSE2 OR VNL_CONFIG_ENABLE_SSE2_ROUNDING)
ENDIF(CMAKE_COMPILER_IS_GNUCXX)
IF(UNIX)
IF(NOT CMAKE_COMPILER_IS_GNUCXX)
INCLUDE(${ITK_SOURCE_DIR}/CMake/TestNO_ICC_IDYNAMIC_NEEDED.cmake)
TESTNO_ICC_IDYNAMIC_NEEDED(NO_ICC_IDYNAMIC_NEEDED ${ITK_SOURCE_DIR}/CMake )
IF(NO_ICC_IDYNAMIC_NEEDED)
SET(ITK_REQUIRED_CXX_FLAGS "${ITK_REQUIRED_CXX_FLAGS}")
ELSE(NO_ICC_IDYNAMIC_NEEDED)
SET(ITK_REQUIRED_CXX_FLAGS "${ITK_REQUIRED_CXX_FLAGS} -i_dynamic")
ENDIF(NO_ICC_IDYNAMIC_NEEDED)
ENDIF(NOT CMAKE_COMPILER_IS_GNUCXX)
ENDIF(UNIX)
#
# This line is required for gcc 4.3.3, since ITK uses deprecated header files
# by default.
#
INCLUDE(TestForANSIStreamHeaders)
IF(BORLAND)
SET(ITK_REQUIRED_CXX_FLAGS "${ITK_REQUIRED_CXX_FLAGS} -w- -whid -waus -wpar")
SET(ITK_REQUIRED_C_FLAGS "${ITK_REQUIRED_C_FLAGS} -w- -whid -waus -wpar")
ENDIF(BORLAND)
# Force the use of ansi cxx flags (i.e. -LANG:std on sgi )
IF("x${CMAKE_ANSI_CXXFLAGS}" MATCHES "^x.*[^ ]")
SET(ITK_REQUIRED_CXX_FLAGS "${ITK_REQUIRED_CXX_FLAGS} ${CMAKE_ANSI_CXXFLAGS}")
ENDIF("x${CMAKE_ANSI_CXXFLAGS}" MATCHES "^x.*[^ ]")
IF("x${CMAKE_ANSI_CFLAGS}" MATCHES "^x.*[^ ]")
SET(ITK_REQUIRED_C_FLAGS "${ITK_REQUIRED_C_FLAGS} ${CMAKE_ANSI_CFLAGS}")
ENDIF("x${CMAKE_ANSI_CFLAGS}" MATCHES "^x.*[^ ]")
IF(CMAKE_SYSTEM MATCHES "IRIX.*")
IF(NOT CMAKE_COMPILER_IS_GNUCXX)
SET(ITK_REQUIRED_CXX_FLAGS "${ITK_REQUIRED_CXX_FLAGS} -woff 15,84,1110,1209,1424,1468,3102,3210,3439 -no_auto_include -ptused -no_prelink")
SET(ITK_REQUIRED_LINK_FLAGS "${ITK_REQUIRED_LINK_FLAGS} -Wl,-woff15")
ENDIF(NOT CMAKE_COMPILER_IS_GNUCXX)
ENDIF(CMAKE_SYSTEM MATCHES "IRIX.*")
IF(MINGW)
LINK_LIBRARIES(gdi32)
ENDIF(MINGW)
# Add flags for the SUN compiler to provide all the methods for std::allocator.
#
INCLUDE(${ITK_SOURCE_DIR}/CMake/itkCheckCXXAcceptsFlags.cmake)
itkCHECK_CXX_ACCEPTS_FLAGS("-features=no%anachronisms" SUN_COMPILER)
IF(SUN_COMPILER)
itkCHECK_CXX_ACCEPTS_FLAGS("-library=stlport4" SUN_COMPILER_HAS_STL_PORT_4)
IF(SUN_COMPILER_HAS_STL_PORT_4)
SET(ITK_REQUIRED_CXX_FLAGS "${ITK_REQUIRED_CXX_FLAGS} -library=stlport4")
ENDIF(SUN_COMPILER_HAS_STL_PORT_4)
ENDIF(SUN_COMPILER)
# for the gnu compiler a -D_PTHREADS is needed on sun
# for the native compiler a -mt flag is needed on the sun
IF(CMAKE_USE_PTHREADS)
IF(CMAKE_SYSTEM MATCHES "SunOS.*")
IF(CMAKE_COMPILER_IS_GNUCXX)
SET(ITK_REQUIRED_CXX_FLAGS "${ITK_REQUIRED_CXX_FLAGS} -D_PTHREADS")
ELSE(CMAKE_COMPILER_IS_GNUCXX)
SET(ITK_REQUIRED_CXX_FLAGS "${ITK_REQUIRED_CXX_FLAGS} -mt")
SET(ITK_REQUIRED_C_FLAGS "${ITK_REQUIRED_C_FLAGS} -mt")
ENDIF(CMAKE_COMPILER_IS_GNUCXX)
ENDIF(CMAKE_SYSTEM MATCHES "SunOS.*")
ENDIF(CMAKE_USE_PTHREADS)
IF(WIN32)
SET(ITK_REQUIRED_CXX_FLAGS "${ITK_REQUIRED_CXX_FLAGS} -DNOMINMAX")
ENDIF(WIN32)
#-----------------------------------------------------------------------------
# Test for an Objective-C++ compiler.
SET(ITK_OBJCXX_COMPILER_WORKS 0)
IF(APPLE)
TRY_COMPILE(ITK_OBJCXX_COMPILER_WORKS
${ITK_BINARY_DIR}/CMakeTmp
${ITK_SOURCE_DIR}/CMake/itkTestObjCxxCompiler.mm
OUTPUT_VARIABLE ITK_OBJCXX_TRY_COMPILE_OUTPUT)
IF( ITK_OBJCXX_COMPILER_WORKS )
FILE(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
"Determining if the Objective-C compiler works passed with "
"the following output:\n${ITK_OBJCXX_TRY_COMPILE_OUTPUT}\n\n")
ELSE( ITK_OBJCXX_COMPILER_WORKS )
FILE(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
"Determining if the Objective-C compiler works failed with "
"the following output:\n${ITK_OBJCXX_TRY_COMPILE_OUTPUT}\n\n")
ENDIF( ITK_OBJCXX_COMPILER_WORKS )
ENDIF(APPLE)
# mingw thread support
IF(MINGW)
SET(ITK_REQUIRED_CXX_FLAGS "${ITK_REQUIRED_CXX_FLAGS} -mthreads")
SET(ITK_REQUIRED_C_FLAGS "${ITK_REQUIRED_C_FLAGS} -mthreads")
SET(ITK_REQUIRED_LINK_FLAGS "${ITK_REQUIRED_LINK_FLAGS} -mthreads")
ENDIF(MINGW)
#-----------------------------------------------------------------------------
# Find platform-specific differences in the handling of IEEE floating point
# special values.
INCLUDE(${ITK_SOURCE_DIR}/CMake/CheckBigBitfield.cmake)
CHECK_BIG_BITFIELD(BIGBITFIELD_VALUE ${ITK_SOURCE_DIR}/CMake)
IF(BIGBITFIELD_VALUE)
SET(BIGBITFIELD 1 CACHE INTERNAL "System handles bit-fields larger than 32 bits.")
ELSE(BIGBITFIELD_VALUE)
SET(BIGBITFIELD 0 CACHE INTERNAL "System handles bit-fields larger than 32 bits.")
ENDIF(BIGBITFIELD_VALUE)
INCLUDE(${ITK_SOURCE_DIR}/CMake/TestQnanhibit.cmake)
TEST_QNANHIBIT(QNANHIBIT_VALUE ${ITK_SOURCE_DIR}/CMake)
IF(QNANHIBIT_VALUE)
SET(QNANHIBIT 1 CACHE INTERNAL "The 22nd bit of 32-bit floating-point quiet NaN.")
ELSE(QNANHIBIT_VALUE)
SET(QNANHIBIT 0 CACHE INTERNAL "The 22nd bit of 32-bit floating-point quiet NaN.")
ENDIF(QNANHIBIT_VALUE)
INCLUDE(CheckTypeSize)
#-----------------------------------------------------------------------------
#
# Check types such as long long and __int64
INCLUDE(${ITK_SOURCE_DIR}/CMake/itkTestTypes.cmake)
#-----------------------------------------------------------------------------
# check if the platform has the header file "fenv.h" which has been added as part of the C99 standard
INCLUDE(CheckIncludeFiles)
CHECK_INCLUDE_FILES(fenv.h HAVE_FENV_H)
#-----------------------------------------------------------------------------
# check if the platform has some widely used header files
CHECK_INCLUDE_FILES("unistd.h" HAVE_UNISTD_H)
#
# See if compiler preprocessor has the __FUNCTION__ directive used by itkExceptionMacro
#
INCLUDE(${ITK_SOURCE_DIR}/CMake/CheckCPPDirective.cmake)
CHECK_CPP_DIRECTIVE_EXISTS(__FUNCTION__ ITK_CPP_FUNCTION)
#
# See if compiler support template partial specialization
#
TRY_COMPILE(ITK_SUPPORTS_TEMPLATE_PARTIAL_SPECIALIZATION
${ITK_BINARY_DIR}/CMakeTmp
${ITK_SOURCE_DIR}/CMake/itkTestTemplatePartialSpecialization.cxx
OUTPUT_VARIABLE ITK_SUPPORTS_TEMPLATE_PARTIAL_SPECIALIZATION_OUTPUT)
#
# Figure out how the compiler likes to declare templated functions as friends
# of a templated class.
#
INCLUDE(${ITK_SOURCE_DIR}/CMake/itkTestFriendTemplatedFunction.cmake)
#-----------------------------------------------------------------------------
# check if the platform has c style IO functions that uses wchar_t * filenames
# For some reason I can't manage to get a usable result from CHECK_FUNCTION_EXISTS
TRY_COMPILE(ITK_SUPPORTS_WCHAR_T_FILENAME_CSTYLEIO
${ITK_BINARY_DIR}/CMakeTmp
${ITK_SOURCE_DIR}/CMake/itkTestCStyleIOWCharFilename.cxx
OUTPUT_VARIABLE ITK_SUPPORTS_WCHAR_T_FILENAME_CSTYLEIO_OUTPUT)
#-----------------------------------------------------------------------------
# check if the platform has IO streams constructors that uses wchar_t * filenames
TRY_COMPILE(ITK_SUPPORTS_WCHAR_T_FILENAME_IOSTREAMS_CONSTRUCTORS
${ITK_BINARY_DIR}/CMakeTmp
${ITK_SOURCE_DIR}/CMake/itkTestIOStreamsWCharFilenameConstructors.cxx
OUTPUT_VARIABLE ITK_SUPPORTS_WCHAR_T_FILENAME_IOSTREAMS_CONSTRUCTORS_OUTPUT)
#-----------------------------------------------------------------------------
# check if the platform can compile fdstream.hpp
IF(HAVE_UNISTD_H)
TRY_COMPILE(ITK_SUPPORTS_FDSTREAM_HPP
${ITK_BINARY_DIR}/CMakeTmp
${ITK_SOURCE_DIR}/CMake/itkTestFDStream.cxx
CMAKE_FLAGS -DINCLUDE_DIRECTORIES:STRING=${ITK_SOURCE_DIR}/Utilities/itkExtHdrs
COMPILE_DEFINITIONS -DITK_HAVE_UNISTD_H=${HAVE_UNISTD_H}
OUTPUT_VARIABLE ITK_SUPPORTS_FDSTREAM_HPP_OUTPUT)
ELSE(HAVE_UNISTD_H)
TRY_COMPILE(ITK_SUPPORTS_FDSTREAM_HPP
${ITK_BINARY_DIR}/CMakeTmp
${ITK_SOURCE_DIR}/CMake/itkTestFDStream.cxx
CMAKE_FLAGS -DINCLUDE_DIRECTORIES:STRING=${ITK_SOURCE_DIR}/Utilities/itkExtHdrs
OUTPUT_VARIABLE ITK_SUPPORTS_FDSTREAM_HPP_OUTPUT)
ENDIF(HAVE_UNISTD_H)
#-----------------------------------------------------------------------------
# Configure the default ITK_DATA_ROOT for the location of ITK Data.
FIND_PATH(ITK_DATA_ROOT ITKData.readme ${ITK_SOURCE_DIR}/Testing/Data $ENV{ITK_DATA_ROOT})
MARK_AS_ADVANCED(ITK_DATA_ROOT)
#-----------------------------------------------------------------------------
# Configure the default ITK_BRAINWEB_DATA_ROOT for the location of ITK Data.
# When this data is available, additional 3D tests are enabled.
FIND_PATH(ITK_BRAINWEB_DATA_ROOT brainweb165a10f17.mha
DOC "Directory with data taken from http://public.kitware.com/pub/itk/Data/BrainWeb/")
MARK_AS_ADVANCED(ITK_BRAINWEB_DATA_ROOT)
#-----------------------------------------------------------------------------
# Configure the default ITK_MRI_UNC_DATABASE_DATA_ROOT for the location of the
# database of healthy volunteers MRI brain images.
# When this data is available, additional 3D tests are enabled.
FIND_PATH(ITK_MRI_UNC_DATABASE_DATA_ROOT LICENSE.txt
DOC "Directory with data taken from http://public.kitware.com/pub/itk/Data/HealthyVolunteersMRIDatabase/")
MARK_AS_ADVANCED(ITK_MRI_UNC_DATABASE_DATA_ROOT)
#-----------------------------------------------------------------------------
# Configure the default ITK_OSIRIX_DATA_ROOT for the location of Data from the Osirix web site.
# When this data is available, additional DICOM tests are enabled.
FIND_PATH(ITK_OSIRIX_DATA_ROOT CEREBRIX
DOC "Directory with data taken from http://www.osirix-viewer.com/Downloads.html")
MARK_AS_ADVANCED(ITK_OSIRIX_DATA_ROOT)
#-----------------------------------------------------------------------------
# Configure the default ITK_VISIBLEHUMAN_DATA_ROOT for the location of Data from the Visible Human Project
# When this data is available, additional Examples are enabled.
FIND_PATH(ITK_VISIBLEHUMAN_DATA_ROOT Male/Fullcolor/fullbody
DOC "Directory with data taken from http://www.nlm.nih.gov/research/visible/getting_data.html")
MARK_AS_ADVANCED(ITK_VISIBLEHUMAN_DATA_ROOT)
#-----------------------------------------------------------------------------
# This flag is used in particular, to enable some tests that require large memory to run.
# This probably can be discovered at configuration time by CMake. (Check with CMake developers).
SET(ITK_COMPUTER_MEMORY_SIZE 1 CACHE STRING "Provide here the size of your RAM Memory in GigaBytes")
MARK_AS_ADVANCED(ITK_COMPUTER_MEMORY_SIZE)
#-----------------------------------------------------------------------------
# Configure files with settings for use by the build.
CONFIGURE_FILE(${ITK_SOURCE_DIR}/itkConfigure.h.in
${ITK_BINARY_DIR}/itkConfigure.h)
IF(NOT ITK_INSTALL_NO_DEVELOPMENT)
INSTALL(FILES ${ITK_BINARY_DIR}/itkConfigure.h
DESTINATION ${ITK_INSTALL_INCLUDE_DIR_CM24}
COMPONENT Development)
ENDIF(NOT ITK_INSTALL_NO_DEVELOPMENT)
#-----------------------------------------------------------------------------
# The entire ITK tree should use the same include path, except for the
# Wrapping directory.
# Create the list of include directories needed for ITK header files.
INCLUDE(${ITK_SOURCE_DIR}/itkIncludeDirectories.cmake)
# This should be the only INCLUDE_DIRECTORIES command in the entire
# tree, except for the Utilities and Wrapping directories. We need to
# do this in one place to make sure the order is correct.
INCLUDE_DIRECTORIES(
${ITK_INCLUDE_DIRS_BUILD_TREE}
${ITK_INCLUDE_DIRS_BUILD_TREE_CXX}
${ITK_INCLUDE_DIRS_SYSTEM}
)
#-----------------------------------------------------------------------------
# ITK_USE_SYSTEM_GDCM is provided so that you can use an installed or external
# version of gdcm. If its on, you must specify the variables
# Important: INCLUDE(${GDCM_USE_FILE}) *has* to be set after the
# INCLUDE_DIRECTORIES that sets all the include paths for ITK, otherwise
# if GDCM was build with VTK support, including it will bring the VTK
# include paths as well, and the wrong DICOMParser will be picked.
OPTION(ITK_USE_SYSTEM_GDCM "Use an outside build of GDCM." OFF)
MARK_AS_ADVANCED(ITK_USE_SYSTEM_GDCM)
IF(ITK_USE_SYSTEM_GDCM)
FIND_PACKAGE(GDCM)
IF(GDCM_FOUND)
INCLUDE(${GDCM_USE_FILE})
IF( "${GDCM_MAJOR_VERSION}" LESS 2.0 )
SET(ITK_GDCM_LIBRARIES gdcm)
ELSE( "${GDCM_MAJOR_VERSION}" LESS 2.0 )
IF(ITK_USE_SYSTEM_TIFF)
# Long story short. ITKIO is NOT linked to itkjpeg8 explicitely. itkjpeg8 dep is being
# pulled from linking to itktiff. However in case of ITK_SYSTEM_TIFF the FindTIFF module
# do not explicitely link to the system jpeg. One can check however that on most GNU/Linux system
# $ ldd /usr/lib/libtiff.so
# linux-vdso.so.1 => (0x00007fff67fff000)
# libjpeg.so.62 => /usr/lib/libjpeg.so.62 (0x00007f635f9f2000)
# As a side note, ITK_SYSTEM_TIFF is somewhat robust as itkjpeg8 dep can also be pulled from
# linking to the default gdcm libraries since they use the itkjpeg libraries.
# I do not know the correct fix:
# 1. Have FindTIFF link to jpeg8 (which would be the right thing to do for static system libtiff)
# 2. Have ITKIO explicitely link to itkjpeg8
# For the time being let's explicitely pull the dep to itkjpeg8 ourselves.
SET(ITK_GDCM_LIBRARIES gdcmMSFF itkjpeg8)
ELSE(ITK_USE_SYSTEM_TIFF)
SET(ITK_GDCM_LIBRARIES gdcmMSFF)
ENDIF(ITK_USE_SYSTEM_TIFF)
ENDIF( "${GDCM_MAJOR_VERSION}" LESS 2.0 )
ELSE(GDCM_FOUND)
MESSAGE(FATAL_ERROR "Must set GDCM_DIR for ITK_USE_SYSTEM_GDCM.")
ENDIF(GDCM_FOUND)
ELSE(ITK_USE_SYSTEM_GDCM)
SET(ITK_GDCM_LIBRARIES itkgdcm)
SET(GDCM_INCLUDE_DIR
${ITK_SOURCE_DIR}/Utilities/gdcm/src
)
ENDIF(ITK_USE_SYSTEM_GDCM)
#-----------------------------------------------------------------------------
# Help other projects use ITK.
# Copy the UseITK.cmake file to the binary tree for backward compatability.
CONFIGURE_FILE(${ITK_SOURCE_DIR}/UseITK.cmake.in
${ITK_BINARY_DIR}/UseITK.cmake COPYONLY IMMEDIATE)
# Save the compiler settings so another project can import them.
INCLUDE(${CMAKE_ROOT}/Modules/CMakeExportBuildSettings.cmake)
CMAKE_EXPORT_BUILD_SETTINGS(${ITK_BINARY_DIR}/ITKBuildSettings.cmake)
# Save library dependencies.
EXPORT_LIBRARY_DEPENDENCIES(${ITK_BINARY_DIR}/ITKLibraryDepends.cmake)
# Create the ITKConfig.cmake file containing the ITK configuration.
INCLUDE (${ITK_SOURCE_DIR}/itkGenerateITKConfig.cmake)
IF(NOT ITK_INSTALL_NO_DEVELOPMENT)
INSTALL(FILES
${ITK_BINARY_DIR}/ITKBuildSettings.cmake
${ITK_BINARY_DIR}/ITKLibraryDepends.cmake
${ITK_BINARY_DIR}/UseITK.cmake
DESTINATION ${ITK_INSTALL_PACKAGE_DIR_CM24}
COMPONENT Development
)
ENDIF(NOT ITK_INSTALL_NO_DEVELOPMENT)
#-----------------------------------------------------------------------------
# Add compiler flags ITK needs to work on this platform. This must be
# done AFTER the call to CMAKE_EXPORT_BUILD_SETTINGS.
SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${ITK_REQUIRED_C_FLAGS}")
SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${ITK_REQUIRED_CXX_FLAGS}")
SET(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${ITK_REQUIRED_LINK_FLAGS}")
SET(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} ${ITK_REQUIRED_LINK_FLAGS}")
SET(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} ${ITK_REQUIRED_LINK_FLAGS}")
#-----------------------------------------------------------------------------
# The frename-registers option does not work due to a bug in the gnu compiler.
# It must be removed or data errors will be produced and incorrect results
# will be produced. This is first documented in the gcc4 man page.
IF(CMAKE_COMPILER_IS_GNUCXX)
SET(ALL_FLAGS "${CMAKE_C_FLAGS} ${CMAKE_CXX_FLAGS} ${CMAKE_EXE_LINKER_FLAGS} ${CMAKE_SHARED_LINKER_FLAGS} ${CMAKE_MODULE_LINKER_FLAGS}" )
SEPARATE_ARGUMENTS(ALL_FLAGS)
FOREACH(COMP_OPTION ${ALL_FLAGS})
IF("${COMP_OPTION}" STREQUAL "-frename-registers")
MESSAGE(FATAL_ERROR "-frename-registers causes runtime bugs. It must be removed from your compilation options.")
ENDIF("${COMP_OPTION}" STREQUAL "-frename-registers")
IF("${COMP_OPTION}" STREQUAL "-ffloat-store")
MESSAGE(FATAL_ERROR "-ffloat-store causes runtime bugs on gcc 3.2.3 (appearently not on gcc 3.4.3, but the exact criteria is not known). It must be removed from your compilation options.")
ENDIF("${COMP_OPTION}" STREQUAL "-ffloat-store")
ENDFOREACH(COMP_OPTION)
ENDIF(CMAKE_COMPILER_IS_GNUCXX)
Jump to Line
Something went wrong with that request. Please try again.