set(ITK_OLDEST_VALIDATED_POLICIES_VERSION "3.22.1")

set(ITK_NEWEST_VALIDATED_POLICIES_VERSION "3.29.0")

cmake_minimum_required(

VERSION

${ITK_OLDEST_VALIDATED_POLICIES_VERSION}...${ITK_NEWEST_VALIDATED_POLICIES_VERSION}

FATAL_ERROR

)

foreach(pnew)

if(POLICY ${pnew})

cmake_policy(SET ${pnew} NEW)

endif()

endforeach()

foreach(pold "")

if(POLICY ${pold})

cmake_policy(SET ${pold} OLD)

endif()

endforeach()

include(${CMAKE_CURRENT_SOURCE_DIR}/CMake/ITKInitializeCXXStandard.cmake)

include(${CMAKE_CURRENT_SOURCE_DIR}/CMake/ITKInitializeBuildType.cmake)

if(CMAKE_CXX_STANDARD EQUAL "98" OR CMAKE_CXX_STANDARD LESS "17")

message(

FATAL_ERROR

"C++98 to C++14 are no longer supported in ITK version 5.4 and greater."

)

endif()

set(

CMAKE_MODULE_PATH

${CMAKE_CURRENT_SOURCE_DIR}/CMake

${CMAKE_MODULE_PATH}

)

include(itkVersion)

set(

ITK_VERSION

"${ITK_VERSION_MAJOR}.${ITK_VERSION_MINOR}.${ITK_VERSION_PATCH}"

)

project(

ITK

VERSION ${ITK_VERSION}

DESCRIPTION

"The Insight Toolkit (ITK) is an open-source, cross-platform toolkit for N-dimensional scientific image processing, segmentation, and registration."

HOMEPAGE_URL "https://itk.org"

LANGUAGES

CXX

C

)

include(itkVersionTweak)

set(

ITK_CMAKE_DIR

"${ITK_SOURCE_DIR}/CMake"

CACHE INTERNAL

"Directory containing CMake files for ITK configuration and module macros"

FORCE

)

if(APPLE)

include(itkApple)

endif()

include(itkCompilerChecks)

include(itkSupportMacros)

set(ITK_CONFIG_CMAKE_DIR "${ITK_SOURCE_DIR}/CMake")

set(ITK_USE_FILE "${ITK_CONFIG_CMAKE_DIR}/UseITK.cmake")

include(itkCCacheSupport)

configure_file(

CMake/ITKInternalConfig.cmake

${ITK_BINARY_DIR}/CMakeTmp/ITKConfig.cmake

COPYONLY

)

include(CMakeDependentOption)

include(ExternalProject)

if(CMAKE_HOST_WIN32)

if(NOT DEFINED ITK_SKIP_PATH_LENGTH_CHECKS)

if(${CMAKE_SYSTEM_VERSION} VERSION_GREATER "10.0.14392") # Win10 version 1607

set(_LongPathKey LongPathsEnabled)

execute_process(

COMMAND

reg query HKLM\\SYSTEM\\CurrentControlSet\\Control\\FileSystem /v

${_LongPathKey}

OUTPUT_VARIABLE _output

)

string(

REGEX

MATCH

"${_LongPathKey}.*REG_DWORD.*[0-9]x([0-9])"

_regex

${_output}

)

if(${CMAKE_MATCH_1})

set(

ITK_SKIP_PATH_LENGTH_CHECKS

0

CACHE BOOL

"Skips max path length checks. These checks can be disabled for Windows version 10.0.14393 and later if registry key HKLM\\SYSTEM\\CurrentControlSet\\Control\\FileSystem\\LongPathsEnabled is set to 1 and all tools support long paths. As of January 2018, MSBuild and Visual Studio do not support it yet."

)

endif()

endif()

endif()

endif()

if(CMAKE_HOST_WIN32 AND NOT ITK_SKIP_PATH_LENGTH_CHECKS)

string(LENGTH "${CMAKE_CURRENT_SOURCE_DIR}" n)

if(n GREATER 50)

message(

FATAL_ERROR

"ITK source code directory path length is too long (${n} > 50)."

"Please move the ITK source code directory to a directory with a shorter path."

)

endif()

string(LENGTH "${CMAKE_CURRENT_BINARY_DIR}" n)

if(n GREATER 50)

message(

FATAL_ERROR

"ITK build directory path length is too long (${n} > 50)."

"Please set the ITK build directory to a directory with a shorter path."

)

endif()

endif()

if(NOT EXISTS "${ITK_SOURCE_DIR}/.ExternalData/README.rst")

# This file is always present in version-controlled source trees

# so we must have been extracted from a source tarball with no

# data objects needed for testing. Turn off tests by default

# since enabling them requires network access or manual data

# store configuration.

option(BUILD_TESTING "Build the testing tree." OFF)

endif()

include(CTest)

mark_as_advanced(CLEAR BUILD_TESTING)

if(MSVC) #-- Configure MSVC_STATIC_RUNTIME only if using MSVC environment

option(

ITK_MSVC_STATIC_RUNTIME_LIBRARY

"Link to MSVC's static CRT (/MT and /MTd).

OFF

)

mark_as_advanced(ITK_MSVC_STATIC_RUNTIME_LIBRARY)

set(ITK_MSVC_STATIC_CRT ${ITK_MSVC_STATIC_RUNTIME_LIBRARY})

if(ITK_MSVC_STATIC_RUNTIME_LIBRARY)

set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")

message(STATUS "Using MSVC's static CRT (/MT and /MTd)")

else()

set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>DLL")

message(STATUS "Using MSVC's dynamic CRT (/MD and /MDd)")

endif()

endif()

include(ITKDownloadSetup)

include(PreventInSourceBuilds)

include(PreventInBuildInstalls)

include(ITKModuleMacros)

include(ITKExternalData)

include(ITKModuleTest)

include(itkCheckSourceTree)

set(main_project_name ${_ITKModuleMacros_DEFAULT_LABEL})

configure_file(CMake/ITKConfigVersion.cmake.in ITKConfigVersion.cmake @ONLY)

if(NOT DEFINED ITK_LIBRARY_NAMESPACE)

set(ITK_LIBRARY_NAMESPACE "ITK")

endif()

set(

ITK_LOAD_FUNCTION_NAME

"itkLoad"

CACHE STRING

"Name of the C entry point ObjectFactoryBase looks up in each autoloaded library."

)

mark_as_advanced(ITK_LOAD_FUNCTION_NAME)

if(NOT ITK_LOAD_FUNCTION_NAME MATCHES "^[A-Za-z_][A-Za-z0-9_]*$")

message(

FATAL_ERROR

"ITK_LOAD_FUNCTION_NAME must be a valid C identifier, got '${ITK_LOAD_FUNCTION_NAME}'"

)

endif()

if(NOT CMAKE_INSTALL_LIBDIR)

set(CMAKE_INSTALL_LIBDIR lib)

endif()

if(NOT ITK_INSTALL_RUNTIME_DIR)

set(ITK_INSTALL_RUNTIME_DIR bin)

endif()

if(NOT ITK_INSTALL_LIBRARY_DIR)

set(ITK_INSTALL_LIBRARY_DIR ${CMAKE_INSTALL_LIBDIR})

endif()

if(NOT ITK_INSTALL_ARCHIVE_DIR)

set(ITK_INSTALL_ARCHIVE_DIR ${CMAKE_INSTALL_LIBDIR})

endif()

if(NOT ITK_INSTALL_INCLUDE_DIR)

set(

ITK_INSTALL_INCLUDE_DIR

include/ITK-${ITK_VERSION_MAJOR}.${ITK_VERSION_MINOR}

)

endif()

if(NOT ITK_INSTALL_DATA_DIR)

set(ITK_INSTALL_DATA_DIR share/ITK-${ITK_VERSION_MAJOR}.${ITK_VERSION_MINOR})

endif()

if(NOT ITK_INSTALL_DOC_DIR)

set(

ITK_INSTALL_DOC_DIR

share/doc/ITK-${ITK_VERSION_MAJOR}.${ITK_VERSION_MINOR}

)

endif()

if(NOT ITK_INSTALL_PACKAGE_DIR)

set(

ITK_INSTALL_PACKAGE_DIR

"${CMAKE_INSTALL_LIBDIR}/cmake/ITK-${ITK_VERSION_MAJOR}.${ITK_VERSION_MINOR}"

)

endif()

foreach(

_itk_install_dir_var

ITK_INSTALL_RUNTIME_DIR

ITK_INSTALL_LIBRARY_DIR

ITK_INSTALL_ARCHIVE_DIR

ITK_INSTALL_INCLUDE_DIR

ITK_INSTALL_DATA_DIR

ITK_INSTALL_DOC_DIR

ITK_INSTALL_PACKAGE_DIR

)

if(IS_ABSOLUTE "${${_itk_install_dir_var}}")

message(

FATAL_ERROR

"${_itk_install_dir_var} ('${${_itk_install_dir_var}}') must be relative to CMAKE_INSTALL_PREFIX."

)

endif()

endforeach()

unset(_itk_install_dir_var)

macro(verify_itk_module_is_set)

if("" STREQUAL "${itk-module}")

message(FATAL_ERROR "CMake variable itk-module is not set")

endif()

endmacro()

option(

ITK_USE_SYSTEM_LIBRARIES

"Use the system's libraries by default.

OFF

)

mark_as_advanced(ITK_USE_SYSTEM_LIBRARIES)

option(

ITK_USE_BRAINWEB_DATA

"Download and use BrainWeb data for advanced testing"

OFF

)

mark_as_advanced(ITK_USE_BRAINWEB_DATA)

if(ITK_BRAINWEB_DATA_ROOT)

message(

WARNING

"ITK_BRAINWEB_DATA_ROOT is not longer supported!"

"Please update to ITK_USE_BRAINWEB_DATA."

)

endif()

if(CMAKE_C_COMPILER_ARG1)

message(

WARNING

"The CMake variable CMAKE_C_COMPILER_ARG1 is set. This most\

)

endif()

option(BUILD_SHARED_LIBS "Build ITK with shared libraries." OFF)

set(ITK_BUILD_SHARED_LIBS ${BUILD_SHARED_LIBS})

if(NOT BUILD_SHARED_LIBS)

set_boolean_with_change_warning(BUILD_SHARED_LIBS OFF)

set_boolean_with_change_warning(BUILD_STATIC_LIBS ON)

else()

set_boolean_with_change_warning(BUILD_SHARED_LIBS ON)

set_boolean_with_change_warning(BUILD_STATIC_LIBS OFF)

endif()

mark_as_advanced(BUILD_STATIC_LIBS)

set(ITK_DYNAMIC_LOADING_DEFAULT ON)

if(WASI OR EMSCRIPTEN)

set(ITK_DYNAMIC_LOADING_DEFAULT OFF)

endif()

option(

ITK_DYNAMIC_LOADING

"Support run-time loading of shared libraries"

${ITK_DYNAMIC_LOADING_DEFAULT}

)

mark_as_advanced(ITK_DYNAMIC_LOADING)

include(Wrapping/CMakeUtilityFunctions.cmake)

include(Wrapping/WrappingOptions.cmake)

set(ITK_USE_AUTOLOAD_PATH OFF)

if(ITK_DYNAMIC_LOADING AND NOT ITK_WRAPPING)

set(ITK_USE_AUTOLOAD_PATH ON)

endif()

include(ITKSetStandardCompilerFlags)

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}"

)

if(NOT CMAKE_POSITION_INDEPENDENT_CODE)

set(CMAKE_POSITION_INDEPENDENT_CODE ON)

endif()

set(

CMAKE_DEBUG_POSTFIX

""

CACHE STRING

"Generate debug library name with a postfix."

)

mark_as_advanced(CMAKE_DEBUG_POSTFIX)

if(NOT DEFINED CMAKE_FIND_USE_PACKAGE_REGISTRY)

set(CMAKE_FIND_USE_PACKAGE_REGISTRY 0)

endif()

include(WrappingConfigCommon)

if(NOT CMAKE_LIBRARY_OUTPUT_DIRECTORY)

set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${ITK_BINARY_DIR}/${CMAKE_INSTALL_LIBDIR})

endif()

if(NOT CMAKE_RUNTIME_OUTPUT_DIRECTORY)

set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${ITK_BINARY_DIR}/bin)

endif()

if(NOT CMAKE_ARCHIVE_OUTPUT_DIRECTORY)

set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${ITK_BINARY_DIR}/${CMAKE_INSTALL_LIBDIR})

endif()

if(CMAKE_CONFIGURATION_TYPES AND ITK_WRAPPING)

add_custom_target(

remove_all_wrapped_libs

COMMAND

${CMAKE_COMMAND} -E rm -rf ${ITK_PYTHON_PACKAGE_DIR}/*.so

${ITK_PYTHON_PACKAGE_DIR}/*.dylib ${ITK_PYTHON_PACKAGE_DIR}/*.dll

WORKING_DIRECTORY ${ITK_BINARY_DIR}

COMMENT

"A convenience target to cleanup library directories when

)

endif()

set(ITK_MODULES_DIR "${ITK_BINARY_DIR}/${ITK_INSTALL_PACKAGE_DIR}/Modules")

cmake_dependent_option(

ITK_LEGACY_REMOVE

"Remove current legacy code completely."

OFF

"NOT ITK_WRAPPING"

ON

)

cmake_dependent_option(

ITK_FUTURE_LEGACY_REMOVE

"Completely remove compilation of code which will become deprecated by default in ITKv6."

OFF

"ITK_LEGACY_REMOVE"

OFF

)

cmake_dependent_option(

ITK_LEGACY_SILENT

"Silence all legacy code messages when ITK_LEGACY_REMOVE:BOOL=OFF."

OFF

"NOT ITK_LEGACY_REMOVE"

OFF

)

mark_as_advanced(

ITK_LEGACY_SILENT

ITK_LEGACY_REMOVE

ITK_FUTURE_LEGACY_REMOVE

)

if(ITKV4_COMPATIBILITY)

message(

FATAL_ERROR

"ITKV4_COMPATIBILITY is removed starting in ITK version 6.0, this option is no longer valid."

)

endif()

if(ITKV3_COMPATIBILITY)

message(

FATAL_ERROR

"ITKV3_COMPATIBILITY is removed starting in ITK version 5.0, this option is no longer valid."

)

endif()

set(

ITK_NIFTI_IO_ANALYZE_FLAVOR_DOC_STRING

"Which flavour of Analyze reader to use by default"

)

set(

ITK_NIFTI_IO_ANALYZE_FLAVOR

"ITK4Warning"

CACHE STRING

${ITK_NIFTI_IO_ANALYZE_FLAVOR_DOC_STRING}

)

set_property(

CACHE

ITK_NIFTI_IO_ANALYZE_FLAVOR

PROPERTY

STRINGS

ITK4Warning

ITK4

SPM

FSL

Reject

)

if(

NOT

(

"${ITK_NIFTI_IO_ANALYZE_FLAVOR}"

STREQUAL

"ITK4Warning"

OR

"${ITK_NIFTI_IO_ANALYZE_FLAVOR}"

STREQUAL

"ITK4"

OR

"${ITK_NIFTI_IO_ANALYZE_FLAVOR}"

STREQUAL

"SPM"

OR

"${ITK_NIFTI_IO_ANALYZE_FLAVOR}"

STREQUAL

"FSL"

OR

"${ITK_NIFTI_IO_ANALYZE_FLAVOR}"

STREQUAL

"Reject"

)

)

set(

ITK_NIFTI_IO_ANALYZE_FLAVOR

"ITK4Warning"

CACHE STRING

${ITK_NIFTI_IO_ANALYZE_FLAVOR_DOC_STRING}

FORCE

)

endif()

mark_as_advanced(ITK_NIFTI_IO_ANALYZE_FLAVOR)

option(

ITK_NIFTI_IO_SFORM_PERMISSIVE_DEFAULT

"Allow non-orthogonal rotation matrix in NIFTI sform by default"

OFF

)

mark_as_advanced(ITK_NIFTI_IO_SFORM_PERMISSIVE_DEFAULT)

if(ITK_USE_REVIEW AND NOT Module_ITKReview)

message(

WARNING

"ITK_USE_REVIEW is deprecated, please use Module_ITKReview to turn Review module ON/OFF"

)

set(

Module_ITKReview

ON

CACHE BOOL

"Module containing code from the Review directory of ITKv4."

FORCE

)

endif()

include(${ITK_SOURCE_DIR}/Utilities/KWStyle/KWStyle.cmake)

option(BUILD_EXAMPLES "Build the examples from the ITK Software Guide." OFF)

option(

ITK_USE_GPU

"GPU acceleration via OpenCL (DEPRECATED; see https://github.com/InsightSoftwareConsortium/ITK/issues/6075)"

OFF

)

mark_as_advanced(ITK_USE_GPU)

if(ITK_USE_GPU)

message(

DEPRECATION

"ITK_USE_GPU enables the OpenCL-based in-tree GPU modules, which are "

"scheduled for removal in ITK 6 "

"(see https://github.com/InsightSoftwareConsortium/ITK/issues/6075). "

"OpenCL is deprecated on macOS and these modules have no CI coverage. "

"For modern GPU acceleration use RTK/CudaCommon (CUDA), ITKVkFFTBackend "

"(Vulkan), or watch "

"https://github.com/InsightSoftwareConsortium/ITK/issues/4433 for the "

"`std::execution` roadmap."

)

include(itkOpenCL)

endif()

option(

ITK_USE_MKL

"Use system Intel Math Kernel Library (MKL) for FFT computation."

OFF

)

mark_as_advanced(ITK_USE_MKL)

if(ITK_USE_MKL)

# The following lines are only useful if one sets `ITK_USE_MKL` to ON in

# the command line. Otherwise, the first CMake run will always initialize

# these variables to false. The error message will help the user to set

# the appropriate values.

set(ITK_USE_FFTWD ON CACHE BOOL "Use double precision FFTW if found")

set(ITK_USE_FFTWF ON CACHE BOOL "Use single precision FFTW if found")

set(ITK_USE_SYSTEM_FFTW ON CACHE BOOL "Use an installed version of FFTW")

if(NOT ITK_USE_FFTWD OR NOT ITK_USE_FFTWF OR NOT ITK_USE_SYSTEM_FFTW)

message(

FATAL_ERROR

"ITK_USE_MKL is set to ON. ITK_USE_FFTWD, ITK_USE_FFTWF\

)

endif()

endif()

option(

ITK_USE_CUFFTW

"Use NVidia CUDA cuFFT with its FFTW interface for FFT computation."

OFF

)

mark_as_advanced(ITK_USE_CUFFTW)

if(ITK_USE_CUFFTW)

# The following lines are only useful if one sets `ITK_USE_CUFFTW` to ON in

# the command line. Otherwise, the first CMake run will always initialize

# these variables to false. The error message will help the user to set

# the appropriate values.

set(ITK_USE_FFTWD ON CACHE BOOL "Use double precision FFTW if found")

set(ITK_USE_FFTWF ON CACHE BOOL "Use single precision FFTW if found")

set(ITK_USE_SYSTEM_FFTW ON CACHE BOOL "Use an installed version of FFTW")

if(NOT ITK_USE_FFTWD OR NOT ITK_USE_FFTWF OR NOT ITK_USE_SYSTEM_FFTW)

message(

FATAL_ERROR

"ITK_USE_CUFFTW is set to ON. ITK_USE_FFTWD, ITK_USE_FFTWF\

)

endif()

endif()

if(DEFINED USE_FFTWD)

set(ITK_USE_FFTWD_DEFAULT ${USE_FFTWD})

else()

set(ITK_USE_FFTWD_DEFAULT OFF)

endif()

option(

ITK_USE_FFTWD

"Use double precision FFTW if found"

${ITK_USE_FFTWD_DEFAULT}

)

mark_as_advanced(ITK_USE_FFTWD)

if(DEFINED USE_FFTWF)

set(ITK_USE_FFTWF_DEFAULT ${USE_FFTWF})

else()

set(ITK_USE_FFTWF_DEFAULT OFF)

endif()

option(

ITK_USE_FFTWF

"Use single precision FFTW if found"

${ITK_USE_FFTWF_DEFAULT}

)

mark_as_advanced(ITK_USE_FFTWF)

if(DEFINED USE_SYSTEM_FFTW)

set(ITK_USE_SYSTEM_FFTW_DEFAULT ${USE_SYSTEM_FFTW})

else()

set(ITK_USE_SYSTEM_FFTW_DEFAULT ${ITK_USE_SYSTEM_LIBRARIES})

endif()

option(

ITK_USE_SYSTEM_FFTW

"Use an installed version of FFTW"

${ITK_USE_SYSTEM_FFTW_DEFAULT}

)

mark_as_advanced(ITK_USE_SYSTEM_FFTW)

set(ITK_USE_64BITS_IDS_DEFAULT "OFF")

if(CMAKE_SIZEOF_VOID_P EQUAL "8" AND WIN32)

set(ITK_USE_64BITS_IDS_DEFAULT "ON")

endif()

option(

ITK_USE_64BITS_IDS

"When ON, ITK will use 64-bit integer types instead of long types for sizes and indexes. This is needed for managing images larger than 4Gb in some platforms."

"${ITK_USE_64BITS_IDS_DEFAULT}"

)

mark_as_advanced(ITK_USE_64BITS_IDS)

if(ITK_USE_CONCEPT_CHECKING)

message(

WARNING

"Ignoring ITK_USE_CONCEPT_CHECKING, as concept checking is performed unconditionally. This variable is no longer used"

)

endif()

if(ITK_USE_STRICT_CONCEPT_CHECKING)

message(

WARNING

"Compilers requiring ITK_USE_STRICT_CONCEPT_CHECKING are no longer supported. This variable is no longer used."

)

endif()

if(ITK_WRAPPING)

set(CMAKE_POSITION_INDEPENDENT_CODE 1)

endif()

set(ITK_TEST_OUTPUT_DIR "${ITK_BINARY_DIR}/Testing/Temporary")

set(ITK_DATA_ROOT ${ITK_SOURCE_DIR}/Testing/Data)

set(ITK_EXAMPLE_DATA_ROOT "${ITK_SOURCE_DIR}/Examples/Data")

cmake_host_system_information(

RESULT ITK_COMPUTER_MEMORY_AVAILABLE_MB

QUERY

TOTAL_PHYSICAL_MEMORY

)

math(

EXPR

EIGHTY_PERCENT_AVAILABLE_MEMORY_IN_GB

"(${ITK_COMPUTER_MEMORY_AVAILABLE_MB} * 80) / ( 1024 * 100)"

)

set(

ITK_COMPUTER_MEMORY_SIZE

${EIGHTY_PERCENT_AVAILABLE_MEMORY_IN_GB}

CACHE STRING

"Provide here the size of your RAM in gibibytes"

)

unset(EIGHTY_PERCENT_AVAILABLE_MEMORY_IN_GB)

unset(ITK_COMPUTER_MEMORY_AVAILABLE_MB)

mark_as_advanced(ITK_COMPUTER_MEMORY_SIZE)

option(

ITK_USE_FLOAT_SPACE_PRECISION

"Use single precision for origin/spacing/directions in itk::Image"

OFF

)

mark_as_advanced(ITK_USE_FLOAT_SPACE_PRECISION)

if(ITK_USE_FLOAT_SPACE_PRECISION AND ITK_WRAP_PYTHON)

message(

FATAL_ERROR

"ITK_USE_FLOAT_SPACE_PRECISION=ON not supported with ITK_WRAP_PYTHON=ON"

)

endif()

option(DISABLE_MODULE_TESTS "Disable all ITK module tests in `test` folder" OFF)

mark_as_advanced(DISABLE_MODULE_TESTS)

if(BUILD_TESTING OR ITK_BUILD_DOCUMENTATION OR ITK_WRAP_PYTHON)

set(PYTHON_DEVELOPMENT_REQUIRED ${ITK_WRAP_PYTHON})

include(${CMAKE_CURRENT_SOURCE_DIR}/CMake/ITKSetPython3Vars.cmake)

if(ITK_WRAP_PYTHON AND NOT Python3_INCLUDE_DIRS)

message(

FATAL_ERROR

"Python version ${Python3_VERSION} development environment not found for wrapping."

)

endif()

if(NOT Python3_ROOT_DIR)

get_filename_component(Python3_ROOT_DIR ${Python3_EXECUTABLE} DIRECTORY)

endif()

endif()

include(itkCheckForOrphanedRemoteModules)

add_subdirectory(Modules/Remote)

include(ITKModuleEnablement)

include(ITKClangTidySetup)

set(

ITK_CONFIG_CODE

"

)

file(TO_CMAKE_PATH "${Python3_EXECUTABLE}" ITK_CONFIG_PYTHON3_EXECUTABLE)

set(ITK_CONFIG_TARGETS_CONDITION " AND NOT ITK_BINARY_DIR")

set(ITK_CONFIG_TARGETS_FILE "${ITK_BINARY_DIR}/ITKTargets.cmake")

set(ITK_CONFIG_MODULE_API_FILE "${ITK_SOURCE_DIR}/CMake/ITKModuleAPI.cmake")

configure_file(CMake/ITKConfig.cmake.in ITKConfig.cmake @ONLY)

set(

ITK_CONFIG_CODE

"

)

string(REGEX REPLACE "/" ";" _count "${ITK_INSTALL_PACKAGE_DIR}")

foreach(p ${_count})

set(

ITK_CONFIG_CODE

"${ITK_CONFIG_CODE}

)

endforeach()

set(

ITK_CONFIG_CODE

"${ITK_CONFIG_CODE}

)

set(

ITK_USE_FILE

"\${ITK_INSTALL_PREFIX}/${ITK_INSTALL_PACKAGE_DIR}/UseITK.cmake"

)

set(ITK_CONFIG_CMAKE_DIR "\${ITK_INSTALL_PREFIX}/${ITK_INSTALL_PACKAGE_DIR}")

set(ITK_CONFIG_TARGETS_CONDITION "")

set(

ITK_CONFIG_TARGETS_FILE

"\${ITK_INSTALL_PREFIX}/${ITK_INSTALL_PACKAGE_DIR}/ITKTargets.cmake"

)

set(

ITK_CONFIG_MODULE_API_FILE

"\${ITK_INSTALL_PREFIX}/${ITK_INSTALL_PACKAGE_DIR}/ITKModuleAPI.cmake"

)

configure_file(CMake/ITKConfig.cmake.in CMakeFiles/ITKConfig.cmake @ONLY)

install(

FILES

${ITK_BINARY_DIR}/CMakeFiles/ITKConfig.cmake

${ITK_BINARY_DIR}/ITKConfigVersion.cmake

CMake/ITKModuleAPI.cmake

CMake/UseITK.cmake

CMake/ITKFactoryRegistration.cmake

CMake/itkFFTImageFilterInitFactoryRegisterManager.h.in

CMake/itkImageIOFactoryRegisterManager.h.in

CMake/itkTransformIOFactoryRegisterManager.h.in

CMake/itkMeshIOFactoryRegisterManager.h.in

CMake/ITKInitializeCXXStandard.cmake

# The transitive closure of include(ITKModuleExternal).

CMake/ITKModuleExternal.cmake

CMake/ITKModuleExternalSettings.cmake

CMake/ITKModuleMacros.cmake

CMake/ITKModuleTest.cmake

CMake/ITKModuleInfo.cmake.in

CMake/ITKSetPython3Vars.cmake

CMake/ITKInitializeBuildType.cmake

CMake/ITKWindowsUtf8.cmake

CMake/Windows-utf8-codepage.manifest

CMake/ITKExternalData.cmake

CMake/ITKDownloadSetup.cmake

CMake/FindFFTW.cmake

CMake/ExternalData.cmake

CMake/ExternalData_config.cmake.in

CMake/WrappingConfigCommon.cmake

CMake/itkRemoveTestFiles.cmake

CMake/ITKModuleDoxygen.cmake

CMake/ITKModuleHeaderTest.cmake

CMake/ITKModuleKWStyleTest.cmake

CMake/ITKModuleCPPCheckTest.cmake

CMake/CppcheckTargets.cmake

# Remote modules include it through ITK_CMAKE_DIR for their version strings.

CMake/GetGitRevisionDescription.cmake

CMake/itkVersion.cmake

Utilities/Maintenance/BuildHeaderTest.py

Utilities/Doxygen/mcdoc.py

DESTINATION ${ITK_INSTALL_PACKAGE_DIR}

COMPONENT Development

)

get_property(ITKTargets_MODULES GLOBAL PROPERTY ITKTargets_MODULES)

if(ITKTargets_MODULES)

install(

EXPORT ITKTargets

DESTINATION ${ITK_INSTALL_PACKAGE_DIR}

COMPONENT Development

)

else()

set(CMAKE_CONFIGURABLE_FILE_CONTENT "# No targets!")

configure_file(

${CMAKE_ROOT}/Modules/CMakeConfigurableFile.in

${ITK_BINARY_DIR}/CMakeFiles/ITKTargets.cmake

@ONLY

)

install(

FILES

${ITK_BINARY_DIR}/CMakeFiles/ITKTargets.cmake

DESTINATION ${ITK_INSTALL_PACKAGE_DIR}

COMPONENT Development

)

endif()

install(

FILES

"LICENSE"

"NOTICE"

"README.md"

DESTINATION ${ITK_INSTALL_DOC_DIR}

COMPONENT Runtime

)

if(BUILD_TESTING)

# If building the testing, write the test costs (i.e. time to run)

# analysis to disk to more easily review long-running test times

set(

CTEST_COST_DATA_FILE

"${CMAKE_BINARY_DIR}/test_cost.list"

CACHE FILEPATH

"Configurable path to CTest cost data file."

)

mark_as_advanced(CTEST_COST_DATA_FILE)

add_subdirectory(CMake/Tests)

add_subdirectory(Utilities/InstallTest)

endif()

set(ITK_DIR "${ITK_BINARY_DIR}")

if(ITK_WRAPPING)

add_subdirectory(Wrapping)

endif()

if(BUILD_EXAMPLES)

add_subdirectory(Examples)

endif()

add_subdirectory(Utilities/Doxygen)

include(ExternalData)

ExternalData_Add_Target(ITKData)

mark_as_advanced(

FORCE

Module_AdaptiveDenoising

Module_AnisotropicDiffusionLBR

Module_BioCell

Module_BoneEnhancement

Module_BoneMorphometry

Module_BSplineGradient