CMakeLists.txt

#
# Teem: Tools to process and visualize scientific data and images
# Copyright (C) 2013, 2012, 2011, 2010, 2009  University of Chicago
# Copyright (C) 2008, 2007, 2006, 2005  Gordon Kindlmann
# Copyright (C) 2004, 2003, 2002, 2001, 2000, 1999, 1998  University of Utah
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public License
# (LGPL) as published by the Free Software Foundation; either
# version 2.1 of the License, or (at your option) any later version.
# The terms of redistributing and/or modifying this software also
# include exceptions to the LGPL that facilitate static linking.
#
# This library is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
# Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with this library; if not, write to Free Software Foundation, Inc.,
# 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
#

# This is the root Teem CMakeLists file
cmake_minimum_required(VERSION 2.8)

# Cmake shouldn't define WIN32 when compiling
set(CMAKE_LEGACY_CYGWIN_WIN32 0)

# As of CMake 2.6 Policies were introduced in order to provide a mechanism for
# adding backwards compatibility one feature at a time.

# Library paths (/path/to/libmy.so not translated to -L/path/to -lmy)
cmake_policy(SET CMP0003 NEW)
if(POLICY CMP0033)
# The ``export_library_dependencies()`` command should not be called.
# The functionality has been superseded by export() and install(EXPORT) commands
  cmake_policy(SET CMP0033 NEW)
endif()
if(POLICY CMP0054)
#Only interpret ``if()`` arguments as variables or keywords when unquoted.
  cmake_policy(SET CMP0054 OLD)
endif()

project(Teem)

#-----------------------------------------------------------------------------
# Teem version number.  Must reflect the values in teem/src/air/air.h
set(Teem_VERSION_MAJOR "1")
set(Teem_VERSION_MINOR "12")
set(Teem_VERSION_PATCH "0")

# Version string should not include patch level.  The major.minor is
# enough to distinguish available features of the toolkit.
set(Teem_VERSION_STRING "${Teem_VERSION_MAJOR}.${Teem_VERSION_MINOR}.${Teem_VERSION_PATCH}")

set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_SOURCE_DIR}/CMake")

# We need ansi c-flags, especially on HP
set(CMAKE_C_FLAGS "${CMAKE_ANSI_CFLAGS} ${CMAKE_C_FLAGS}")
set(CMAKE_REQUIRED_FLAGS ${CMAKE_ANSI_CFLAGS})

# adding cmake debug postfix to distinguish between release and debug libs
set(CMAKE_DEBUG_POSTFIX "d")

#-----------------------------------------------------------------------------
# Test for some required system information.
include (CMakeBackwardCompatibilityC)

#-----------------------------------------------------------------------------
# Output directories.

foreach(type LIBRARY RUNTIME ARCHIVE)
  # Make sure the directory exists
  if(DEFINED CMAKE_${type}_OUTPUT_DIRECTORY
     AND NOT EXISTS ${CMAKE_${type}_OUTPUT_DIRECTORY})
    message(FATAL_ERROR "CMAKE_${type}_OUTPUT_DIRECTORY is set to a non-existing directory [${CMAKE_${type}_OUTPUT_DIRECTORY}]")
  endif()
  if(NOT DEFINED CMAKE_${type}_OUTPUT_DIRECTORY)
    set(CMAKE_${type}_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
  endif()
endforeach()

if(BUILD_SHARED_LIBS)
  set(__LIBRARY_OUTPUT_PATH__ "${CMAKE_LIBRARY_OUTPUT_DIRECTORY}")
else()
  set(__LIBRARY_OUTPUT_PATH__ "${CMAKE_ARCHIVE_OUTPUT_DIRECTORY}")
endif()
set(__RUNTIME_OUTPUT_PATH_ "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}")

#output directory for installing all include files.")

file(MAKE_DIRECTORY ${Teem_BINARY_DIR}/include)
file(MAKE_DIRECTORY ${Teem_BINARY_DIR}/include/teem)

#-----------------------------------------------------------------------------
# Find platform-specific differences in the handling of IEEE floating point
# special values.

include(${Teem_SOURCE_DIR}/CMake/TestQnanhibit.cmake)
TEST_QNANHIBIT(QNANHIBIT_VALUE ${Teem_SOURCE_DIR}/CMake)
if(QNANHIBIT_VALUE)
  set(QNANHIBIT 1 CACHE INTERNAL "The 22nd bit of 32-bit floating-point quiet NaN.")
else()
  set(QNANHIBIT 0 CACHE INTERNAL "The 22nd bit of 32-bit floating-point quiet NaN.")
endif()


#-----------------------------------------------------------------------------
# test if AIR_EXISTS macro fails
try_run(AIR_EXISTS_MACRO_FAILS AIR_EXISTS_MACRO_COMPILE
  ${CMAKE_CURRENT_BINARY_DIR} ${CMAKE_CURRENT_LIST_DIR}/CMake/testAirExists.cxx
)

#-----------------------------------------------------------------------------
# Teem build configuration options.
option(BUILD_SHARED_LIBS "Build Teem with shared libraries." OFF)
set(Teem_BUILD_SHARED_LIBS ${BUILD_SHARED_LIBS})
if(NOT Teem_BUILD_SHARED_LIBS)
  add_definitions(-DTEEM_STATIC)
endif()

option(Teem_ZLIB "Build Teem with support for gzip compression." ON)
option(Teem_PNG "Build Teem with support for PNG images." ON)
option(Teem_VTK_MANGLE "Build Teem using the mangled libraries from VTK for ZLIB and PNG." OFF)
set(Teem_VTK_ZLIB_MANGLE_IPATH "" CACHE PATH "Location of vtk_zlib_mangle.h")
set(Teem_VTK_TOOLKITS_IPATH "" CACHE PATH "Location of VTK Build directory for ZLIB and PNG includes.")

# Can't build PNG without ZLIB, so force it on.
if(Teem_PNG AND NOT Teem_ZLIB)
  set(Teem_ZLIB ON)
endif()

if(Teem_VTK_MANGLE)
  add_definitions(-DTEEM_VTK_MANGLE=1)
  include_directories( ${Teem_VTK_TOOLKITS_IPATH} )
  include_directories( ${Teem_VTK_ZLIB_MANGLE_IPATH} )
endif()


set(Teem_ZLIB_LIB "")
set(Teem_PNG_LIB "")
if(Teem_ZLIB)
  # Find ZLIB
  find_package(ZLIB)
  if(ZLIB_FOUND)
    add_definitions(-DTEEM_ZLIB)
    set(Teem_ZLIB_LIB ${ZLIB_LIBRARIES})
    set(Teem_ZLIB_IPATH ${ZLIB_INCLUDE_DIR})
  else()
    # We need to set this as a cache variable, so that it will show up as
    # being turned off in the cache.
    message("warning: Turning off Teem_ZLIB, because it wasn't found.")
    set(Teem_ZLIB OFF CACHE BOOL "Build Teem with support for gzip compression." FORCE)
  endif()

  if(Teem_PNG)
    find_package(PNG)
    if(PNG_FOUND)
      add_definitions(-DTEEM_PNG ${PNG_DEFINITIONS})
      set(Teem_PNG_LIB ${PNG_LIBRARIES})
      set(Teem_PNG_IPATH ${PNG_INCLUDE_DIR})
    else()
      # We need to set this as a cache variable, so that it will show up as
      # being turned off in the cache.
      message("warning: Turning off Teem_PNG, because it wasn't found.")
      set(Teem_PNG OFF CACHE BOOL "Build Teem with support for PNG images." FORCE)
    endif()
  endif()
endif()

# Try and locate BZIP2 stuff
option(Teem_BZIP2 "Build Teem with support for bzip compression." ON)
set(Teem_BZIP2_LIB "")

if(Teem_BZIP2)
  find_package(BZ2)

  if(BZ2_FOUND)
    add_definitions(-DTEEM_BZIP2)
    set(Teem_BZIP2_LIB ${BZ2_LIBRARIES})
    set(Teem_BZIP2_IPATH ${BZ2_INCLUDE_DIR})
  else()
    # We need to set this as a cache variable, so that it will show up as
    # being turned off in the cache.
    message("warning: Turning off Teem_BZIP2, because it wasn't found.")
    set(Teem_BZIP2 OFF CACHE BOOL "Build Teem with support for bzip compression." FORCE)
  endif()
endif()

# Look for threading libraries
option(Teem_PTHREAD "Build Teem with pthread library support." ON)
if(Teem_PTHREAD)
  include(FindThreads)
  if(CMAKE_USE_PTHREADS_INIT)
    add_definitions(-DTEEM_PTHREAD)
  else()
    # We need to set this as a cache variable, so that it will show up as
    # being turned off in the cache.
    message("warning: Turning off Teem_PTHREAD, because it wasn't found.")
    set(Teem_PTHREAD OFF CACHE BOOL "Build Teem with pthread library support." FORCE)
    set(Teem_PTHREAD OFF)
  endif()
endif()

# Look for "levmar" library <http://www.ics.forth.gr/~lourakis/levmar/>
option(Teem_LEVMAR "Build Teem with levmar library support." OFF)
set(Teem_LEVMAR_LIB "")
if(Teem_LEVMAR)
  find_package(LEVMAR)

  if(LEVMAR_FOUND)
    add_definitions(-DTEEM_LEVMAR)
    set(Teem_LEVMAR_LIB ${LEVMAR_LIBRARIES})
    set(Teem_LEVMAR_IPATH ${LEVMAR_INCLUDE_DIR})
  else()
    # We need to set this as a cache variable, so that it will show up as
    # being turned off in the cache.
    message("warning: Turning off Teem_LEVMAR, because it wasn't found.")
    set(Teem_LEVMAR OFF CACHE BOOL "Build Teem with levmar library support." FORCE)
  endif()
endif()

# Look for fftw <http://www.fftw.org/>
option(Teem_FFTW3 "Build Teem with fftw library support." OFF)
set(Teem_FFTW3_LIB "")

if(Teem_FFTW3)
  find_package(FFTW3)

  if(FFTW3_FOUND)
    add_definitions(-DTEEM_FFTW3)
    set(Teem_FFTW3_LIB ${FFTW3_LIBRARIES})
    set(Teem_FFTW3_IPATH ${FFTW3_INCLUDE_DIR})
  else()
    # We need to set this as a cache variable, so that it will show up as
    # being turned off in the cache.
    message("warning: Turning off Teem_FFTW3, because it wasn't found.")
    set(Teem_FFTW3 OFF CACHE BOOL "Build Teem with fftw library support." FORCE)
  endif()
endif()

#-----------------------------------------------------------------------------

if(${CMAKE_GENERATOR} MATCHES "Visual Studio")
  # For Visual Studio we don't care about warnings about deprecated sprintf and
  # the like.
  add_definitions(-D_CRT_SECURE_NO_DEPRECATE -D_CRT_NONSTDC_NO_DEPRECATE)
endif()

#Teem Defines
#The QNANHIBIT variable is configured by the root level CMakeLists.txt
if(QNANHIBIT)
  add_definitions(-DTEEM_QNANHIBIT=1)
else()
  add_definitions(-DTEEM_QNANHIBIT=0)
endif()

#DirectIO is the fast way to do multi-gigabyte I/O and currently only available
#for SGI platforms.  Use of DirectIO is enabled manually for now.
#option(USE_DIRECTIO "Use DirectIO for Nrrd file IO.  Only valid on SGI systems." 0)
#mark_as_advanced(USE_DIRECTIO)
#if(USE_DIRECTIO)
#  add_definitions(-DTEEM_DIO=1)
#else()
add_definitions(-DTEEM_DIO=0)
#endif()

set(BUILD_EXPERIMENTAL_LIBS OFF CACHE BOOL "Build Teem's experimental libraries")
set(BUILD_EXPERIMENTAL_APPS OFF CACHE BOOL "Build Teem's non-essential command-line tools")

# If its a Dashboard build; turn ON both
# BUILD_EXPERIMENTAL_APPS and BUILD_EXPERIMENTAL_LIBS
# (h/t David Cole)
if(NOT "$ENV{DASHBOARD_TEST_FROM_CTEST}" STREQUAL "")
  # it is a dashboard build
  set(BUILD_EXPERIMENTAL_APPS ON)
  set(BUILD_EXPERIMENTAL_LIBS ON)
endif()

# (TEEM_LIB_LIST)
set(Teem_COMPONENTS air hest biff nrrd ell unrrdu moss gage dye limn echo hoover seek ten pull mite meet)
if(BUILD_EXPERIMENTAL_LIBS)
  # This list of the "experimental" libraries must be kept in sync with:
  # * definition of Teem_HEADER_FILES (below)
  # * teem/src/meet/meet.h
  # * teem/src/meet/enumsall.c
  # re-setting list so libraries appear in expected order
  list(APPEND Teem_COMPONENTS alan tijk bane elf coil push)
  add_definitions(-DTEEM_BUILD_EXPERIMENTAL_LIBS)
endif()

if(BUILD_EXPERIMENTAL_APPS)
  add_definitions(-DTEEM_BUILD_EXPERIMENTAL_APPS)
endif()

set(Teem_HEADER_FILES
  air/air.h
  hest/hest.h
  biff/biff.h
  nrrd/nrrd.h   nrrd/nrrdDefines.h   nrrd/nrrdMacros.h  nrrd/nrrdEnums.h
  ell/ell.h     ell/ellMacros.h
  unrrdu/unrrdu.h
  moss/moss.h
  gage/gage.h
  dye/dye.h
  limn/limn.h
  echo/echo.h
  hoover/hoover.h
  seek/seek.h
  ten/ten.h     ten/tenMacros.h
  pull/pull.h
  mite/mite.h
  meet/meet.h
  )
if(BUILD_EXPERIMENTAL_LIBS)
  set(Teem_HEADER_FILES ${Teem_HEADER_FILES}
    alan/alan.h
    tijk/tijk.h
    bane/bane.h
    elf/elf.h
    coil/coil.h
    push/push.h
    )
endif()

# Include directory
include_directories(
  "${Teem_BINARY_DIR}/include/"
  "${Teem_SOURCE_DIR}/include/"
  )


## Add external library path includes
if(Teem_ZLIB)
  include_directories(${Teem_ZLIB_IPATH})
  include_directories(${Teem_ZLIB_DLLCONF_IPATH})
  if(Teem_PNG)
    include_directories(${Teem_PNG_IPATH})
    include_directories(${Teem_PNG_DLLCONF_IPATH})
  endif()
endif()

if(Teem_BZIP2)
  include_directories(${Teem_BZIP2_IPATH})
endif()

if(Teem_LEVMAR)
  include_directories(${Teem_LEVMAR_IPATH})
endif()

if(Teem_FFTW3)
  include_directories(${Teem_FFTW3_IPATH})
endif()

# All the source files
set(Teem_SOURCES)

#-----------------------------------------------------------------------------
# Macro for adding the current set of source files to the master list
# Additionally addition option for each libary part that allows for enabling
# and/or disabling it within the build
# 
# When option Teem_BUILD_MONOLITHIC is set to true (default) then teem will build
# exactly one library containing all symbols. Teem_BUILD_MONOLITHIC is disabled
# teem will export a number of libraries that can be used independently
# 

option(Teem_BUILD_MONOLITHIC "Enable this to get one monolithic library containing all symbols" ON)
macro(ADD_TEEM_LIBRARY target)
  include(CMakeParseArguments)
  cmake_parse_arguments(_arg "" "" "DEPENDENCIES" ${ARGN})

  string(TOUPPER ${target} LIBNAME_UC)
  option(Teem_BUILD_WITH_${LIBNAME_UC} "Enable building ${target}" ON)
  if(Teem_BUILD_WITH_${LIBNAME_UC})
    set(srcs)
    foreach(src ${_arg_UNPARSED_ARGUMENTS})
      set(srcs ${srcs} "src/${target}/${src}")
    endforeach()

    if(Teem_BUILD_MONOLITHIC)
      set(Teem_SOURCES ${Teem_SOURCES} ${srcs})
      # This will group all the source files in the VS project by directory
      source_group( ${target} FILES ${srcs} )
    else()
      add_library(${target} ${srcs})
      if(_arg_DEPENDENCIES)
        target_link_libraries(${target} ${_arg_DEPENDENCIES})
      endif()
      list(APPEND Teem_LIBRARIES ${target})
    endif()
  endif()
endmacro()


#-----------------------------------------------------------------------------
# Dispatch the build into the proper subdirectories.
# Additionally addition option for each libary part that allows for enabling
# and/or disabling it within the build
foreach(dir ${Teem_COMPONENTS})
  include(src/${dir}/sources.cmake)
endforeach()

set(Teem_INSTALLED_HEADER_FILES)
foreach(header_file ${Teem_HEADER_FILES})
  # When debugging, uncomment this line
  #message(STATUS "Copy header file: ${header_file}")
  get_filename_component(file_no_path "${header_file}" NAME)
  get_filename_component(component "${header_file}" DIRECTORY)
  string(TOUPPER ${component} COMPONENT_UC)

  # only copy headers of components that are build
  if(Teem_BUILD_WITH_${COMPONENT_UC})
    configure_file("${CMAKE_CURRENT_SOURCE_DIR}/src/${header_file}"
      "${CMAKE_CURRENT_BINARY_DIR}/include/teem/${file_no_path}" COPYONLY)
    set(Teem_INSTALLED_HEADER_FILES
      ${Teem_INSTALLED_HEADER_FILES}
      "${CMAKE_CURRENT_BINARY_DIR}/include/teem/${file_no_path}")
  endif()
endforeach()

#---
# header that defines AIR_EXISTS_MACRO_FAILS
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/CMake/airExistsConf.h
  ${CMAKE_CURRENT_BINARY_DIR}/include/teem/airExistsConf.h)
set(Teem_INSTALLED_HEADER_FILES
  ${Teem_INSTALLED_HEADER_FILES}
  "${CMAKE_CURRENT_BINARY_DIR}/include/teem/airExistsConf.h")
#---

#-----------------------------------------------------------------------------
# Build the Mega library
#
# This needs to occur after the parsing of the subdirectories.

# Create the library target
set(Teem_NAMESPACE "teem")
if(Teem_BUILD_MONOLITHIC)
  set(Teem_LIBRARIES teem)
  set(Teem_NAMESPACE "")
  add_library(teem ${Teem_SOURCES})
endif()

# Set up some library paths for installation.  Windows will ingore the
# RPATH stuff, and mac will ingore the INSTALL_RPATH.  Make sure for
# macs to set BUILD_WITH_INSTALL_RPATH OFF and set INSTALL_NAME_DIR.
# I belive INSTALL_NAME_DIR will be ignored on linux.
foreach(target ${Teem_LIBRARIES})
  set_target_properties(${target} PROPERTIES
    BUILD_WITH_INSTALL_RPATH OFF
    INSTALL_RPATH ${CMAKE_INSTALL_PREFIX}/lib
    INSTALL_NAME_DIR ${CMAKE_INSTALL_PREFIX}/lib
    SOVERSION 1
    VERSION ${Teem_VERSION_STRING}
    )

  if(Teem_BZIP2_LIB)
    target_link_libraries(${target} ${Teem_BZIP2_LIB})
  endif()
  if(Teem_ZLIB_LIB)
    target_link_libraries(${target} ${Teem_ZLIB_LIB})
    if(Teem_PNG_LIB)
      target_link_libraries(${target} ${Teem_PNG_LIB})
    endif()
  endif()

  if(Teem_LEVMAR_LIB)
    target_link_libraries(${target} ${Teem_LEVMAR_LIB})
  endif()

  if(Teem_FFTW3_LIB)
    target_link_libraries(${target} ${Teem_FFTW3_LIB})
  endif()

  if(Teem_PTHREAD)
    target_link_libraries(${target} ${CMAKE_THREAD_LIBS_INIT})
  endif()

  if(UNIX)
    target_link_libraries(${target} -lm)
  endif()
endforeach()


option(Teem_USE_LIB_INSTALL_SUBDIR "Add a Teem-X.Y.Z directory layer to the installation tree for libraries and archives." OFF)
if(Teem_USE_LIB_INSTALL_SUBDIR)
  set(EXTRA_INSTALL_PATH /Teem-${Teem_VERSION_STRING})
else()
  set(EXTRA_INSTALL_PATH "")
endif()

install(TARGETS ${Teem_LIBRARIES}
  EXPORT teem-targets
  RUNTIME DESTINATION bin COMPONENT RuntimeLibraries
  LIBRARY DESTINATION lib/${EXTRA_INSTALL_PATH} COMPONENT RuntimeLibraries
  ARCHIVE DESTINATION lib/${EXTRA_INSTALL_PATH} COMPONENT Development
)

install(EXPORT teem-targets DESTINATION cmake)

# Stand-alone programs to process hex encoding of data
option(BUILD_HEX "Build dehex and enhex" OFF)
if(BUILD_HEX)
  add_subdirectory(src/hex)
endif()

#-----------------------------------------------------------------------------
# For testing
option(BUILD_TESTING "Enable this to perform testing of Teem" ON)

if(BUILD_TESTING)
  include(CTest)
  enable_testing()
  set(BUILDNAME "${BUILDNAME}" CACHE STRING "Name of build on the dashboard")
  mark_as_advanced(BUILDNAME)
  mark_as_advanced(TCL_TCLSH)
endif()

#-----------------------------------------------------------------------------
# Now compile the binaries
add_subdirectory(src/bin)

if(BUILD_TESTING)
  add_subdirectory(Testing)
endif()

#-----------------------------------------------------------------------------
# OUTDATED Help outside projects build Teem projects.
set(Teem_CV_BUILD_SETTINGS_FILE ${Teem_BINARY_DIR}/TeemBuildSettings.cmake)
set(Teem_CV_BUILD_SETTINGS_FILE "\${Teem_ROOT_DIR}/lib${EXTRA_INSTALL_PATH}/TeemBuildSettings.cmake")
file(WRITE ${Teem_BINARY_DIR}/TeemBuildSettings.cmake "# This file should NOT be used.
# It is currently provided so that backwards compatibility with external projects
# can be preserved.  External packages that include TeemBuildSettings.cmake should
# stop using this feature.
# 
# CMake Error at cmake/Modules/CMakeExportBuildSettings.cmake:17 (message):
# The functionality of the CMakeExportBuildSettings module has been dropped as of CMake 2.8.  It was
# deemed harmful (confusing users by changing their compiler).  Please remove
# calls to the CMAKE_EXPORT_BUILD_SETTINGS macro and stop including this
# module.  If this project generates any files for use by external projects,
# remove any use of the CMakeImportBuildSettings module from them.
# include(CMakeExportBuildSettings)
# CMAKE_EXPORT_BUILD_SETTINGS(${Teem_BINARY_DIR}/TeemBuildSettings.cmake)
#")

set(CFLAGS "${CMAKE_C_FLAGS}")
set(CC "${CMAKE_C_COMPILER}")

set(Teem_EXECUTABLE_DIRS ${__RUNTIME_OUTPUT_PATH_} CACHE INTERNAL "Single output directory for building all executables.")


# Teem_CV_ prefixed variables are only used inside TeemConfig.cmake.in for
# replacement during the following two CONFIGURE_FILE calls. One is for use
# from the build tree, one is for use from the install tree.


# For build tree usage

# In the build tree, TeemConfig.cmake is in Teem_BINARY_DIR. The root of the
# tree for finding include files relative to TeemConfig.cmake is "."
#
set(Teem_CV_CONFIG_TO_ROOT ".")
set(Teem_CV_LIBRARY_DEPENDS_FILE ${Teem_BINARY_DIR}/TeemLibraryDepends.cmake)
set(Teem_CV_EXECUTABLE_DIRS ${Teem_EXECUTABLE_DIRS})
set(Teem_CV_LIBRARY_DIRS ${__LIBRARY_OUTPUT_PATH__})
set(Teem_CV_USE_FILE ${Teem_SOURCE_DIR}/CMake/TeemUse.cmake)
set(Teem_CV_INCLUDE_DIRS "${Teem_BINARY_DIR}/include")
set(Teem_CV_BUILT_LIBRARIES teem) # The libraries built by teem.  Currently we only build the mega library.

configure_file("${Teem_SOURCE_DIR}/CMake/TeemConfig.cmake.in"
  "${Teem_BINARY_DIR}/TeemConfig.cmake" @ONLY IMMEDIATE)


# For install tree usage

# In the install tree, TeemConfig.cmake is in lib or lib/Teem-X.Y based on the
# value of Teem_USE_LIB_INSTALL_SUBDIR. The root of the tree for finding
# include files relative to TeemConfig.cmake is therefore ".." or "../.."
#
if(Teem_USE_LIB_INSTALL_SUBDIR)
  set(Teem_CV_CONFIG_TO_ROOT "../..")
else()
  set(Teem_CV_CONFIG_TO_ROOT "..")
endif()

set(Teem_CV_LIBRARY_DEPENDS_FILE "\${Teem_ROOT_DIR}/lib${EXTRA_INSTALL_PATH}/TeemLibraryDepends.cmake")
set(Teem_CV_EXECUTABLE_DIRS "\${Teem_ROOT_DIR}/bin")
set(Teem_CV_LIBRARY_DIRS "\${Teem_ROOT_DIR}/lib${EXTRA_INSTALL_PATH}")
set(Teem_CV_USE_FILE "\${Teem_ROOT_DIR}/lib${EXTRA_INSTALL_PATH}/TeemUse.cmake")
set(Teem_CV_INCLUDE_DIRS "\${Teem_ROOT_DIR}/include")
set(Teem_CV_BUILT_LIBRARIES teem) # The libraries built by teem.  Currently we only build the mega library.

configure_file("${Teem_SOURCE_DIR}/CMake/TeemConfig.cmake.in"
  "${Teem_BINARY_DIR}/CMake/TeemConfig.cmake" @ONLY IMMEDIATE)

install(FILES ${Teem_INSTALLED_HEADER_FILES}
  DESTINATION include/teem
  COMPONENT Development
  )

install(FILES
  "${Teem_BINARY_DIR}/CMake/TeemConfig.cmake"
  "${Teem_SOURCE_DIR}/CMake/TeemUse.cmake"
  "${Teem_BINARY_DIR}/TeemBuildSettings.cmake"
  DESTINATION cmake/${EXTRA_INSTALL_PATH}
  COMPONENT Development
  )