# ----------------------------------------------------------------------------
# Root CMake file for OpenCV
#
# From the off-tree build directory, invoke:
# $ cmake <PATH_TO_OPENCV_ROOT>
#
#
# - OCT-2008: Initial version <joseluisblancoc@gmail.com>
#
# ----------------------------------------------------------------------------
set ( CMAKE_ALLOW_LOOSE_LOOP_CONSTRUCTS true )
# Add these standard paths to the search paths for FIND_LIBRARY
# to find libraries from these locations first
if ( UNIX )
set ( CMAKE_LIBRARY_PATH ${ CMAKE_LIBRARY_PATH } /lib /usr/lib )
endif ( )
# it _must_ go before PROJECT(OpenCV) in order to work
if ( WIN32 )
set ( CMAKE_INSTALL_PREFIX "${CMAKE_BINARY_DIR}/install" CACHE PATH "Installation Directory" )
else ( )
set ( CMAKE_INSTALL_PREFIX "/usr/local" CACHE PATH "Installation Directory" )
endif ( )
set ( CMAKE_CONFIGURATION_TYPES "Debug;Release" CACHE STRING "Configs" FORCE )
if ( DEFINED CMAKE_BUILD_TYPE )
set_property ( CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS ${ CMAKE_CONFIGURATION_TYPES } )
endif ( )
set ( CMAKE_C_FLAGS_MINSIZEREL "" CACHE INTERNAL "" FORCE )
set ( CMAKE_C_FLAGS_RELWITHDEBINFO "" CACHE INTERNAL "" FORCE )
set ( CMAKE_CXX_FLAGS_MINSIZEREL "" CACHE INTERNAL "" FORCE )
set ( CMAKE_CXX_FLAGS_RELWITHDEBINFO "" CACHE INTERNAL "" FORCE )
set ( CMAKE_EXE_LINKER_FLAGS_MINSIZEREL "" CACHE INTERNAL "" FORCE )
set ( CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO "" CACHE INTERNAL "" FORCE )
set ( CMAKE_MODULE_LINKER_FLAGS_MINSIZEREL "" CACHE INTERNAL "" FORCE )
set ( CMAKE_MODULE_LINKER_FLAGS_RELWITHDEBINFO "" CACHE INTERNAL "" FORCE )
set ( CMAKE_SHARED_LINKER_FLAGS_MINSIZEREL "" CACHE INTERNAL "" FORCE )
set ( CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO "" CACHE INTERNAL "" FORCE )
set ( CMAKE_VERBOSE OFF CACHE BOOL "Verbose mode" )
if ( CMAKE_VERBOSE )
set ( CMAKE_VERBOSE_MAKEFILE 1 )
endif ( )
if ( MSVC )
set ( CMAKE_USE_RELATIVE_PATHS ON CACHE INTERNAL "" FORCE )
endif ( )
cmake_minimum_required ( VERSION 2.4 )
project ( OpenCV )
# --------------------------------------------------------------
# Indicate CMake 2.7 and above that we don't want to mix relative
# and absolute paths in linker lib lists.
# Run "cmake --help-policy CMP0003" for more information.
# --------------------------------------------------------------
if ( COMMAND cmake_policy )
cmake_policy ( SET CMP0003 NEW )
endif ( )
# ----------------------------------------------------------------------------
# Build static or dynamic libs?
# Default: dynamic libraries
# ----------------------------------------------------------------------------
set ( BUILD_SHARED_LIBS ON CACHE BOOL "Build shared libraries (.dll/.so) instead of static ones (.lib/.a)" )
# ----------------------------------------------------------------------------
# Get actual OpenCV version number from sources
# ----------------------------------------------------------------------------
FILE ( STRINGS "${CMAKE_CURRENT_SOURCE_DIR}/modules/core/include/opencv2/core/version.hpp" OPENCV_VERSION_PARTS REGEX "#define CV_.+OR_VERSION[ ]+[0-9]+" )
string ( REGEX REPLACE ".+CV_MAJOR_VERSION[ ]+([0-9]+).*" "\\1" OPENCV_VERSION_MAJOR "${OPENCV_VERSION_PARTS}" )
string ( REGEX REPLACE ".+CV_MINOR_VERSION[ ]+([0-9]+).*" "\\1" OPENCV_VERSION_MINOR "${OPENCV_VERSION_PARTS}" )
string ( REGEX REPLACE ".+CV_SUBMINOR_VERSION[ ]+([0-9]+).*" "\\1" OPENCV_VERSION_PATCH "${OPENCV_VERSION_PARTS}" )
set ( OPENCV_VERSION "${OPENCV_VERSION_MAJOR}.${OPENCV_VERSION_MINOR}.${OPENCV_VERSION_PATCH}" )
set ( OPENCV_SOVERSION "${OPENCV_VERSION_MAJOR}.${OPENCV_VERSION_MINOR}" )
if ( WIN32 )
set ( OPENCV_DLL_VERSION_SUFFIX "" )
# Postfix of DLLs:
if ( ${ CMAKE_GENERATOR } MATCHES "(MinGW)|(MSYS)" )
set ( OPENCV_DLL_VERSION_SUFFIX "${OPENCV_DLL_VERSION_SUFFIX}_mingw" )
endif ( )
if ( ${ CMAKE_GENERATOR } MATCHES "Visual.*" )
set ( OPENCV_DLL_VERSION_SUFFIX "${OPENCV_DLL_VERSION_SUFFIX}_vs" )
if ( ${ CMAKE_GENERATOR } MATCHES "Visual Studio 8 2005.*" )
set ( OPENCV_DLL_VERSION_SUFFIX "${OPENCV_DLL_VERSION_SUFFIX}2005" )
endif ( )
if ( ${ CMAKE_GENERATOR } MATCHES "Visual Studio 9 2008.*" )
set ( OPENCV_DLL_VERSION_SUFFIX "${OPENCV_DLL_VERSION_SUFFIX}2008" )
endif ( )
if ( ${ CMAKE_GENERATOR } MATCHES "Visual Studio 10.*" )
set ( OPENCV_DLL_VERSION_SUFFIX "${OPENCV_DLL_VERSION_SUFFIX}2010" )
endif ( )
endif ( )
if ( ${ CMAKE_GENERATOR } MATCHES "Visual Studio.*Win64" )
set ( OPENCV_DLL_VERSION_SUFFIX "${OPENCV_DLL_VERSION_SUFFIX}_64" )
endif ( )
if ( NOT BUILD_SHARED_LIBS )
set ( OPENCV_DLL_VERSION_SUFFIX "${OPENCV_DLL_VERSION_SUFFIX}l" )
endif ( )
set ( OPENCV_DLLVERSION "${OPENCV_VERSION_MAJOR}${OPENCV_VERSION_MINOR}${OPENCV_VERSION_PATCH}${OPENCV_DLL_VERSION_SUFFIX}" )
set ( OPENCV_DEBUG_POSTFIX d )
else ( )
# Postfix of so's:
set ( OPENCV_DLLVERSION "" )
set ( OPENCV_DEBUG_POSTFIX )
endif ( )
#name mangling
set ( OPENCV_INCLUDE_PREFIX include )
if ( UNIX AND NOT ANDROID AND BUILD_SHARED_LIBS )
option ( OPENCV_MANGLED_INSTALL_PATHS "Enables mangled install paths, that help with side by side installs." False )
if ( OPENCV_MANGLED_INSTALL_PATHS )
set ( OPENCV_INCLUDE_PREFIX include/opencv- ${ OPENCV_VERSION } )
endif ( )
endif ( )
# SUBDIRECTORIES:
# Save libs and executables in the same place
set ( LIBRARY_OUTPUT_PATH ${ CMAKE_BINARY_DIR } /lib CACHE PATH "Output directory for libraries" )
set ( EXECUTABLE_OUTPUT_PATH ${ CMAKE_BINARY_DIR } /bin CACHE PATH "Output directory for applications" )
if ( ANDROID OR WIN32 )
set ( OPENCV_DOC_INSTALL_PATH doc )
elseif ( OPENCV_MANGLED_INSTALL_PATHS )
set ( OPENCV_DOC_INSTALL_PATH share/OpenCV- ${ OPENCV_VERSION } /doc )
else ( )
set ( OPENCV_DOC_INSTALL_PATH share/OpenCV/doc )
endif ( )
if ( ANDROID )
set ( OPENCV_LIB_INSTALL_PATH libs/ ${ ARMEABI_NDK_NAME } )
else ( )
set ( OPENCV_LIB_INSTALL_PATH lib )
endif ( )
set ( CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/${OPENCV_LIB_INSTALL_PATH}" )
set ( CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE )
# search packages for host system instead of packages for target system
# in case of cross compilation thess macro should be defined by toolchain file
if ( NOT COMMAND find_host_package )
macro ( find_host_package )
find_package ( ${ ARGN } )
endmacro ( )
endif ( )
if ( NOT COMMAND find_host_program )
macro ( find_host_program )
find_program ( ${ ARGN } )
endmacro ( )
endif ( )
# ----------------------------------------------------------------------------
# Use statically or dynamically linked CRT?
# Default: dynamic
# ----------------------------------------------------------------------------
if ( MSVC AND NOT BUILD_SHARED_LIBS )
option ( BUILD_WITH_STATIC_CRT "Enables use of staticaly linked CRT" OFF )
endif ( )
if ( MSVC )
if ( BUILD_WITH_STATIC_CRT )
foreach ( flag_var
C M A K E _ C _ F L A G S C M A K E _ C _ F L A G S _ D E B U G C M A K E _ C _ F L A G S _ R E L E A S E
C M A K E _ C _ F L A G S _ M I N S I Z E R E L C M A K E _ C _ F L A G S _ R E L W I T H D E B I N F O
C M A K E _ C X X _ F L A G S C M A K E _ C X X _ F L A G S _ D E B U G C M A K E _ C X X _ F L A G S _ R E L E A S E
C M A K E _ C X X _ F L A G S _ M I N S I Z E R E L C M A K E _ C X X _ F L A G S _ R E L W I T H D E B I N F O )
if ( ${ flag_var } MATCHES "/MD" )
string ( REGEX REPLACE "/MD" "/MT" ${ flag_var } "${${flag_var}}" )
endif ( )
if ( ${ flag_var } MATCHES "/MDd" )
string ( REGEX REPLACE "/MDd" "/MTd" ${ flag_var } "${${flag_var}}" )
endif ( )
endforeach ( flag_var )
set ( CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /NODEFAULTLIB:atlthunk.lib /NODEFAULTLIB:msvcrt.lib /NODEFAULTLIB:msvcrtd.lib" )
set ( CMAKE_EXE_LINKER_FLAGS_DEBUG "${CMAKE_EXE_LINKER_FLAGS_DEBUG} /NODEFAULTLIB:libcmt.lib" )
set ( CMAKE_EXE_LINKER_FLAGS_RELEASE "${CMAKE_EXE_LINKER_FLAGS_RELEASE} /NODEFAULTLIB:libcmtd.lib" )
else ( BUILD_WITH_STATIC_CRT )
foreach ( flag_var
C M A K E _ C _ F L A G S C M A K E _ C _ F L A G S _ D E B U G C M A K E _ C _ F L A G S _ R E L E A S E
C M A K E _ C _ F L A G S _ M I N S I Z E R E L C M A K E _ C _ F L A G S _ R E L W I T H D E B I N F O
C M A K E _ C X X _ F L A G S C M A K E _ C X X _ F L A G S _ D E B U G C M A K E _ C X X _ F L A G S _ R E L E A S E
C M A K E _ C X X _ F L A G S _ M I N S I Z E R E L C M A K E _ C X X _ F L A G S _ R E L W I T H D E B I N F O )
if ( ${ flag_var } MATCHES "/MT" )
string ( REGEX REPLACE "/MT" "/MD" ${ flag_var } "${${flag_var}}" )
endif ( )
if ( ${ flag_var } MATCHES "/MTd" )
string ( REGEX REPLACE "/MTd" "/MDd" ${ flag_var } "${${flag_var}}" )
endif ( )
endforeach ( flag_var )
endif ( BUILD_WITH_STATIC_CRT )
endif ( MSVC )
# ----------------------------------------------------------------------------
# Variables for cvconfig.h.cmake
# ----------------------------------------------------------------------------
set ( PACKAGE "opencv" )
set ( PACKAGE_BUGREPORT "opencvlibrary-devel@lists.sourceforge.net" )
set ( PACKAGE_NAME "opencv" )
set ( PACKAGE_STRING "${PACKAGE} ${OPENCV_VERSION}" )
set ( PACKAGE_TARNAME "${PACKAGE}" )
set ( PACKAGE_VERSION "${OPENCV_VERSION}" )
# ----------------------------------------------------------------------------
# Autodetect if we are in a SVN repository
# ----------------------------------------------------------------------------
find_host_program ( SVNVERSION_PATH svnversion )
mark_as_advanced ( force SVNVERSION_PATH )
if ( SVNVERSION_PATH )
message ( STATUS "Extracting svn version, please wait..." )
execute_process ( COMMAND ${ SVNVERSION_PATH } -n ${ OpenCV_SOURCE_DIR } OUTPUT_VARIABLE SVNVERSION_RESULT )
if ( SVNVERSION_RESULT MATCHES "exported" )
# This is NOT a svn repository:
set ( OPENCV_SVNVERSION "" )
message ( STATUS "SVNVERSION: exported" )
else ( )
set ( OPENCV_SVNVERSION " svn:${SVNVERSION_RESULT}" )
message ( STATUS "SVNVERSION: ${OPENCV_SVNVERSION}" )
endif ( )
else ( )
# We don't have svnversion:
set ( OPENCV_SVNVERSION "" )
endif ( )
# ----------------------------------------------------------------------------
# Detect Microsoft compiler:
# ----------------------------------------------------------------------------
if ( CMAKE_CL_64 )
set ( MSVC64 1 )
endif ( )
# ----------------------------------------------------------------------------
# Detect GNU version:
# ----------------------------------------------------------------------------
if ( CMAKE_COMPILER_IS_GNUCXX )
execute_process ( COMMAND ${ CMAKE_CXX_COMPILER } --version
O U T P U T _ V A R I A B L E C M A K E _ O P E N C V _ G C C _ V E R S I O N _ F U L L
O U T P U T _ S T R I P _ T R A I L I N G _ W H I T E S P A C E )
execute_process ( COMMAND ${ CMAKE_CXX_COMPILER } -v
E R R O R _ V A R I A B L E C M A K E _ O P E N C V _ G C C _ I N F O _ F U L L
O U T P U T _ S T R I P _ T R A I L I N G _ W H I T E S P A C E )
# Typical output in CMAKE_OPENCV_GCC_VERSION_FULL: "c+//0 (whatever) 4.2.3 (...)"
# Look for the version number
string ( REGEX MATCH "[0-9]+.[0-9]+.[0-9]+" CMAKE_GCC_REGEX_VERSION "${CMAKE_OPENCV_GCC_VERSION_FULL}" )
# Split the three parts:
string ( REGEX MATCHALL "[0-9]+" CMAKE_OPENCV_GCC_VERSIONS "${CMAKE_GCC_REGEX_VERSION}" )
list ( GET CMAKE_OPENCV_GCC_VERSIONS 0 CMAKE_OPENCV_GCC_VERSION_MAJOR )
list ( GET CMAKE_OPENCV_GCC_VERSIONS 1 CMAKE_OPENCV_GCC_VERSION_MINOR )
set ( CMAKE_OPENCV_GCC_VERSION ${ CMAKE_OPENCV_GCC_VERSION_MAJOR } ${ CMAKE_OPENCV_GCC_VERSION_MINOR } )
math ( EXPR CMAKE_OPENCV_GCC_VERSION_NUM "${CMAKE_OPENCV_GCC_VERSION_MAJOR}*100 + ${CMAKE_OPENCV_GCC_VERSION_MINOR}" )
message ( STATUS "Detected version of GNU GCC: ${CMAKE_OPENCV_GCC_VERSION} (${CMAKE_OPENCV_GCC_VERSION_NUM})" )
if ( WIN32 )
execute_process ( COMMAND ${ CMAKE_CXX_COMPILER } -dumpmachine
O U T P U T _ V A R I A B L E C M A K E _ O P E N C V _ G C C _ T A R G E T _ M A C H I N E
O U T P U T _ S T R I P _ T R A I L I N G _ W H I T E S P A C E )
if ( CMAKE_OPENCV_GCC_TARGET_MACHINE MATCHES "64" )
set ( MINGW64 1 )
endif ( )
endif ( )
endif ( )
# ----------------------------------------------------------------------------
# Detect Intel ICC compiler -- for -fPIC in 3rdparty ( UNIX ONLY ):
# see include/opencv/cxtypes.h file for related ICC & CV_ICC defines.
# NOTE: The system needs to determine if the '-fPIC' option needs to be added
# for the 3rdparty static libs being compiled. The CMakeLists.txt files
# in 3rdparty use the CV_ICC definition being set here to determine if
# the -fPIC flag should be used.
# ----------------------------------------------------------------------------
if ( UNIX )
if ( __ICL )
set ( CV_ICC __ICL )
elseif ( __ICC )
set ( CV_ICC __ICC )
elseif ( __ECL )
set ( CV_ICC __ECL )
elseif ( __ECC )
set ( CV_ICC __ECC )
elseif ( __INTEL_COMPILER )
set ( CV_ICC __INTEL_COMPILER )
elseif ( CMAKE_C_COMPILER MATCHES "icc" )
set ( CV_ICC icc_matches_c_compiler )
endif ( )
endif ( )
# ----------------------------------------------------------------------------
# CHECK FOR SYSTEM LIBRARIES, OPTIONS, ETC..
# ----------------------------------------------------------------------------
# Build/install (or not) some apps:
# ===================================================
set ( BUILD_EXAMPLES OFF CACHE BOOL "Build all examples" )
set ( INSTALL_C_EXAMPLES OFF CACHE BOOL "Install C examples" )
set ( INSTALL_PYTHON_EXAMPLES OFF CACHE BOOL "Install Python examples" )
# Build tests:
# ===================================================
set ( BUILD_TESTS ON CACHE BOOL "Build tests" )
# Build 3rdparty libraries under unix
# ===================================================
if ( WIN32 )
set ( OPENCV_BUILD_3RDPARTY_LIBS TRUE CACHE BOOL "Build 3rd party libraries" )
else ( )
set ( OPENCV_BUILD_3RDPARTY_LIBS FALSE CACHE BOOL "Build 3rd party libraries" )
endif ( )
include ( OpenCVPCHSupport.cmake REQUIRED )
include ( OpenCVModule.cmake REQUIRED )
if ( PCHSupport_FOUND )
SET ( USE_PRECOMPILED_HEADERS ON CACHE BOOL "Use precompiled headers" )
else ( )
SET ( USE_PRECOMPILED_HEADERS OFF CACHE BOOL "Use precompiled headers" FORCE )
endif ( )
if ( UNIX )
include ( OpenCVFindPkgConfig.cmake OPTIONAL )
include ( CheckFunctionExists )
include ( CheckIncludeFile )
endif ( )
if ( CMAKE_COMPILER_IS_GNUCXX )
set ( ENABLE_PROFILING OFF CACHE BOOL "Enable profiling in the GCC compiler (Add flags: -g -pg)" )
set ( USE_OMIT_FRAME_POINTER ON CACHE BOOL "Enable -fomit-frame-pointer for GCC" )
if ( ${ CMAKE_SYSTEM_PROCESSOR } MATCHES amd64*|x86_64* )
set ( X86_64 1 )
endif ( )
if ( ${ CMAKE_SYSTEM_PROCESSOR } MATCHES i686*|i386*|x86* )
set ( X86 1 )
endif ( )
if ( ${ CMAKE_SYSTEM_PROCESSOR } MATCHES powerpc* )
set ( ENABLE_POWERPC ON CACHE BOOL "Enable PowerPC for GCC" )
endif ( )
if ( X86 OR X86_64 )
# enable everything, since the available set of instructions is checked at runtime
set ( USE_FAST_MATH ON CACHE BOOL "Enable -ffast-math" )
set ( ENABLE_SSE ON CACHE BOOL "Enable SSE instructions" )
set ( ENABLE_SSE2 ON CACHE BOOL "Enable SSE2 instructions" )
set ( ENABLE_SSE3 OFF CACHE BOOL "Enable SSE3 instructions" )
set ( ENABLE_SSSE3 OFF CACHE BOOL "Enable SSSE3 instructions" )
set ( ENABLE_SSE41 OFF CACHE BOOL "Enable SSE4.1 instructions" )
set ( ENABLE_SSE42 OFF CACHE BOOL "Enable SSE4.2 instructions" )
endif ( )
endif ( )
if ( MSVC )
set ( ENABLE_SSE ON CACHE BOOL "Enable SSE instructions for MSVC" )
set ( ENABLE_SSE2 ON CACHE BOOL "Enable SSE2 instructions for MSVC" )
if ( CMAKE_C_COMPILER MATCHES "icc" )
set ( ENABLE_SSE3 OFF CACHE BOOL "Enable SSE3 instructions for ICC" )
set ( ENABLE_SSE4_1 OFF CACHE BOOL "Enable SSE4.1 instructions for ICC" )
endif ( )
endif ( )
# allow fine grained control over which libraries not to link, even if
# they are available on the system
# ====================================================================
set ( WITH_PNG ON CACHE BOOL "Include PNG support" )
set ( WITH_JPEG ON CACHE BOOL "Include JPEG support" )
set ( WITH_JASPER ON CACHE BOOL "Include JPEG2K support" )
set ( WITH_TIFF ON CACHE BOOL "Include TIFF support" )
set ( WITH_OPENEXR ON CACHE BOOL "Include ILM support via OpenEXR" )
if ( UNIX )
set ( WITH_FFMPEG ON CACHE BOOL "Include FFMPEG support" )
if ( NOT APPLE )
set ( WITH_UNICAP OFF CACHE BOOL "Include Unicap support (GPL)" )
set ( WITH_GTK ON CACHE BOOL "Include GTK support" )
set ( WITH_GSTREAMER ON CACHE BOOL "Include Gstreamer support" )
set ( WITH_V4L ON CACHE BOOL "Include Video 4 Linux support" )
set ( WITH_XINE OFF CACHE BOOL "Include Xine support (GPL)" )
endif ( )
set ( WITH_PVAPI ON CACHE BOOL "Include Prosilica GigE support" )
set ( WITH_1394 ON CACHE BOOL "Include IEEE1394 support" )
endif ( )
if ( APPLE )
set ( WITH_CARBON OFF CACHE BOOL "Use Carbon for UI instead of Cocoa" )
set ( WITH_QUICKTIME OFF CACHE BOOL "Use QuickTime for Video I/O insted of QTKit" )
endif ( )
set ( WITH_TBB OFF CACHE BOOL "Include Intel TBB support" )
set ( WITH_IPP OFF CACHE BOOL "Include Intel IPP support" )
set ( WITH_EIGEN ON CACHE BOOL "Include Eigen2/Eigen3 support" )
set ( WITH_CUDA ON CACHE BOOL "Include NVidia Cuda Runtime support" )
set ( WITH_OPENNI OFF CACHE BOOL "Include OpenNI support" )
# ===================================================
# Macros that checks if module have been installed.
# After it adds module to build and define
# constants passed as second arg
# ===================================================
macro ( CHECK_MODULE module_name define )
set ( ${ define } 0 )
if ( PKG_CONFIG_FOUND )
set ( ALIAS ALIASOF_ ${ module_name } )
set ( ALIAS_FOUND ${ ALIAS } _FOUND )
set ( ALIAS_INCLUDE_DIRS ${ ALIAS } _INCLUDE_DIRS )
set ( ALIAS_LIBRARY_DIRS ${ ALIAS } _LIBRARY_DIRS )
set ( ALIAS_LIBRARIES ${ ALIAS } _LIBRARIES )
PKG_CHECK_MODULES ( ${ ALIAS } ${ module_name } )
if ( ${ ALIAS_FOUND } )
set ( ${ define } 1 )
foreach ( P "${ALIAS_INCLUDE_DIRS}" )
if ( ${ P } )
list ( APPEND HIGHGUI_INCLUDE_DIRS ${ ${P } } )
endif ( )
endforeach ( )
foreach ( P "${ALIAS_LIBRARY_DIRS}" )
if ( ${ P } )
list ( APPEND HIGHGUI_LIBRARY_DIRS ${ ${P } } )
endif ( )
endforeach ( )
list ( APPEND HIGHGUI_LIBRARIES ${ ${ALIAS_LIBRARIES } } )
endif ( )
endif ( )
endmacro ( )
if ( UNIX )
if ( NOT APPLE )
if ( WITH_GTK )
CHECK_MODULE ( gtk+-2.0 HAVE_GTK )
CHECK_MODULE ( gthread-2.0 HAVE_GTHREAD )
else ( )
set ( HAVE_GTK FALSE )
set ( HAVE_GTHREAD FALSE )
endif ( )
if ( WITH_GSTREAMER )
CHECK_MODULE ( gstreamer-base-0.10 HAVE_GSTREAMER )
CHECK_MODULE ( gstreamer-app-0.10 HAVE_GSTREAMER )
CHECK_MODULE ( gstreamer-video-0.10 HAVE_GSTREAMER )
else ( )
set ( HAVE_GSTREAMER FALSE )
endif ( )
endif ( )
if ( WITH_UNICAP )
CHECK_MODULE ( libunicap HAVE_UNICAP_ )
CHECK_MODULE ( libucil HAVE_UNICAP_UCIL )
if ( HAVE_UNICAP_ AND HAVE_UNICAP_UCIL )
set ( HAVE_UNICAP 1 )
endif ( )
else ( )
set ( HAVE_UNICAP FALSE )
endif ( )
if ( WITH_PVAPI )
find_path ( PVAPI_INCLUDE_PATH "PvApi.h"
P A T H S " / u s r / l o c a l / i n c l u d e " " / u s r / i n c l u d e "
D O C " T h e p a t h t o P v A P I h e a d e r " )
if ( PVAPI_INCLUDE_PATH )
set ( HAVE_PVAPI 1 )
endif ( )
endif ( )
set ( HAVE_FFMPEG 0 )
if ( WITH_FFMPEG )
CHECK_MODULE ( libavcodec HAVE_FFMPEG_CODEC )
CHECK_MODULE ( libavformat HAVE_FFMPEG_FORMAT )
CHECK_MODULE ( libavutil HAVE_FFMPEG_UTIL )
CHECK_MODULE ( libswscale HAVE_FFMPEG_SWSCALE )
CHECK_INCLUDE_FILE ( libavformat/avformat.h HAVE_GENTOO_FFMPEG )
CHECK_INCLUDE_FILE ( ffmpeg/avformat.h HAVE_FFMPEG_FFMPEG )
if ( NOT HAVE_GENTOO_FFMPEG AND NOT HAVE_FFMPEG_FFMPEG )
if ( EXISTS /usr/include/ffmpeg/libavformat/avformat.h OR HAVE_FFMPEG_SWSCALE )
set ( HAVE_GENTOO_FFMPEG 1 )
endif ( )
endif ( )
if ( HAVE_FFMPEG_CODEC AND HAVE_FFMPEG_FORMAT AND HAVE_FFMPEG_UTIL )
if ( HAVE_FFMPEG_SWSCALE OR NOT HAVE_GENTOO_FFMPEG )
set ( HAVE_FFMPEG 1 )
endif ( )
endif ( )
# Find the bzip2 library because it is required on some systems
FIND_LIBRARY ( BZIP2_LIBRARIES NAMES bz2 bzip2 )
if ( NOT BZIP2_LIBRARIES )
# Do an other trial
FIND_FILE ( BZIP2_LIBRARIES NAMES libbz2.so.1 PATHS /lib )
endif ( )
endif ( )
if ( WITH_1394 )
CHECK_MODULE ( libdc1394-2 HAVE_DC1394_2 )
if ( NOT HAVE_DC1394_2 )
CHECK_MODULE ( libdc1394 HAVE_DC1394 )
endif ( )
else ( )
set ( HAVE_DC1394_2 FALSE )
set ( HAVE_DC1394 FALSE )
endif ( )
if ( NOT OPENCV_BUILD_3RDPARTY_LIBS )
include ( FindZLIB )
if ( WITH_PNG )
include ( FindPNG )
if ( PNG_FOUND )
CHECK_INCLUDE_FILE ( ${ PNG_PNG_INCLUDE_DIR } /png.h HAVE_PNG_H )
CHECK_INCLUDE_FILE ( ${ PNG_PNG_INCLUDE_DIR } /libpng/png.h HAVE_LIBPNG_PNG_H )
endif ( )
else ( )
set ( PNG_FOUND FALSE )
endif ( )
if ( WITH_TIFF )
include ( FindTIFF )
else ( )
set ( TIFF_FOUND FALSE )
endif ( )
if ( WITH_JASPER )
include ( FindJasper )
else ( )
set ( JASPER_FOUND FALSE )
endif ( )
if ( WITH_JPEG )
include ( FindJPEG )
else ( )
set ( JPEG_FOUND FALSE )
endif ( )
endif ( )
if ( NOT APPLE )
CHECK_INCLUDE_FILE ( alloca.h HAVE_ALLOCA_H )
CHECK_FUNCTION_EXISTS ( alloca HAVE_ALLOCA )
CHECK_INCLUDE_FILE ( unistd.h HAVE_UNISTD_H )
CHECK_INCLUDE_FILE ( pthread.h HAVE_LIBPTHREAD )
if ( WITH_XINE )
CHECK_MODULE ( libxine HAVE_XINE )
else ( )
set ( HAVE_XINE FALSE )
endif ( )
if ( WITH_V4L )
CHECK_MODULE ( libv4l1 HAVE_LIBV4L )
CHECK_INCLUDE_FILE ( linux/videodev.h HAVE_CAMV4L )
CHECK_INCLUDE_FILE ( linux/videodev2.h HAVE_CAMV4L2 )
else ( )
set ( HAVE_LIBV4L FALSE )
set ( HAVE_CAMV4L FALSE )
set ( HAVE_CAMV4L2 FALSE )
endif ( )
if ( ${ CMAKE_SYSTEM_NAME } MATCHES "FreeBSD" OR ${ CMAKE_SYSTEM_NAME } MATCHES "NetBSD" AND NOT ANDROID )
set ( OPENCV_LINKER_LIBS m pthread )
elseif ( ANDROID )
set ( OPENCV_LINKER_LIBS dl m log )
else ( )
set ( OPENCV_LINKER_LIBS dl m pthread rt )
endif ( )
else ( )
add_definitions ( -DHAVE_ALLOCA -DHAVE_ALLOCA_H -DHAVE_LIBPTHREAD -DHAVE_UNISTD_H )
endif ( )
endif ( )
if ( WITH_PNG AND NOT PNG_FOUND )
set ( PNG_LIBRARIES libpng )
endif ( )
if ( WITH_JPEG AND NOT JPEG_FOUND )
set ( JPEG_LIBRARIES libjpeg )
endif ( )
if ( WITH_TIFF AND NOT TIFF_FOUND )
set ( TIFF_LIBRARIES libtiff )
endif ( )
if ( WITH_JASPER AND NOT JASPER_FOUND )
set ( JASPER_LIBRARIES libjasper )
endif ( )
if ( NOT ZLIB_FOUND )
set ( ZLIB_LIBRARY zlib )
endif ( )
#message(STATUS "Graphic libraries: ${PNG_LIBRARIES} ${JPEG_LIBRARIES} ${TIFF_LIBRARIES} ${JASPER_LIBRARIES}")
if ( WITH_OPENEXR )
include ( OpenCVFindOpenEXR.cmake )
endif ( )
set ( BUILD_DOCS ON CACHE BOOL "Build OpenCV Documentation" )
if ( BUILD_DOCS )
include ( OpenCVFindLATEX.cmake REQUIRED )
endif ( )
set ( BUILD_NEW_PYTHON_SUPPORT ON CACHE BOOL "Build with Python support" )
if ( WIN32 )
if ( "${CMAKE_BUILD_TYPE}" STREQUAL "Debug" )
set ( BUILD_NEW_PYTHON_SUPPORT OFF )
endif ( )
endif ( )
if ( ANDROID )
set ( BUILD_NEW_PYTHON_SUPPORT OFF )
endif ( )
# Always try to find python
# ===================================================
find_host_package ( PythonInterp )
find_host_package ( PythonLibs )
# cmake 2.4 (at least on Ubuntu 8.04 (hardy)) don't define PYTHONLIBS_FOUND
if ( NOT PYTHONLIBS_FOUND AND PYTHON_INCLUDE_PATH )
set ( PYTHONLIBS_FOUND ON )
endif ( )
execute_process ( COMMAND ${ PYTHON_EXECUTABLE } --version
E R R O R _ V A R I A B L E P Y T H O N _ V E R S I O N _ F U L L
O U T P U T _ S T R I P _ T R A I L I N G _ W H I T E S P A C E )
string ( REGEX MATCH "[0-9]+.[0-9]+" PYTHON_VERSION_MAJOR_MINOR "${PYTHON_VERSION_FULL}" )
if ( UNIX )
set ( PYTHON_PLUGIN_INSTALL_PATH lib/python ${ PYTHON_VERSION_MAJOR_MINOR } /site-packages/opencv )
if ( APPLE )
set ( PYTHON_PACKAGES_PATH lib/python ${ PYTHON_VERSION_MAJOR_MINOR } /site-packages CACHE PATH "Where to install the python packages." )
else ( ) #debian based assumed, install to the dist-packages.
set ( PYTHON_PACKAGES_PATH lib/python ${ PYTHON_VERSION_MAJOR_MINOR } /dist-packages CACHE PATH "Where to install the python packages." )
endif ( )
endif ( )
if ( WIN32 )
get_filename_component ( PYTHON_PATH "[HKEY_LOCAL_MACHINE\\SOFTWARE\\Python\\PythonCore\\${PYTHON_VERSION_MAJOR_MINOR}\\InstallPath]" ABSOLUTE CACHE )
set ( PYTHON_PLUGIN_INSTALL_PATH "${PYTHON_PATH}/Lib/site-packages/opencv" )
set ( PYTHON_PACKAGES_PATH "${PYTHON_PATH}/Lib/site-packages" )
endif ( )
IF ( "${PYTHON_VERSION_MAJOR_MINOR}" VERSION_GREATER 2.5.-1 )
SET ( PYTHON_EXECUTABLE ${ PYTHON_EXECUTABLE } -B )
ENDIF ( )
# Attempt to discover the NumPy include directory. If this succeeds, then build python API with NumPy
execute_process ( COMMAND ${ PYTHON_EXECUTABLE } -c "import os; os.environ['DISTUTILS_USE_SDK']='1'; import numpy.distutils; print numpy.distutils.misc_util.get_numpy_include_dirs()[0]"
R E S U L T _ V A R I A B L E P Y T H O N _ N U M P Y _ P R O C E S S
O U T P U T _ V A R I A B L E P Y T H O N _ N U M P Y _ I N C L U D E _ D I R S
O U T P U T _ S T R I P _ T R A I L I N G _ W H I T E S P A C E )
if ( PYTHON_NUMPY_PROCESS EQUAL 0 )
set ( PYTHON_USE_NUMPY 1 )
add_definitions ( -D PYTHON_USE_NUMPY=1 )
include_directories ( AFTER ${ PYTHON_NUMPY_INCLUDE_DIRS } )
message ( STATUS " Use NumPy headers from: ${PYTHON_NUMPY_INCLUDE_DIRS}" )
else ( )
set ( PYTHON_USE_NUMPY 0 )
endif ( )
execute_process ( COMMAND ${ PYTHON_EXECUTABLE } -c "import sphinx; print sphinx.__version__"
R E S U L T _ V A R I A B L E S P H I N X _ P R O C E S S
O U T P U T _ V A R I A B L E S P H I N X _ V E R S I O N
O U T P U T _ S T R I P _ T R A I L I N G _ W H I T E S P A C E )
set ( HAVE_SPHINX 0 )
if ( SPHINX_PROCESS EQUAL 0 )
find_host_program ( SPHINX_BUILD sphinx-build )
if ( SPHINX_BUILD )
set ( HAVE_SPHINX 1 )
message ( STATUS " Found Sphinx ${SPHINX_VERSION}: ${SPHINX_BUILD}" )
endif ( )
endif ( )
# Java support
# ===================================================
if ( PYTHON_EXECUTABLE AND ANDROID )
SET ( BUILD_JAVA_SUPPORT ON CACHE BOOL "Build with Java support" )
else ( )
SET ( BUILD_JAVA_SUPPORT OFF CACHE BOOL "Build with Java support" FORCE )
endif ( )
if ( BUILD_JAVA_SUPPORT AND ( BUILD_EXAMPLES OR BUILD_TESTS ) )
file ( TO_CMAKE_PATH "$ENV{ANT_DIR}" ANT_DIR_ENV_PATH )
file ( TO_CMAKE_PATH "$ENV{ProgramFiles}" ProgramFiles_ENV_PATH )
if ( ANDROID )
file ( TO_CMAKE_PATH "$ENV{ANDROID_SDK}" ANDROID_SDK_ENV_PATH )
#find android SDK
find_host_program ( ANDROID_EXECUTABLE
N A M E S a n d r o i d . b a t a n d r o i d
P A T H S " $ { A N D R O I D _ S D K _ E N V _ P A T H } / t o o l s / "
" $ { P r o g r a m F i l e s _ E N V _ P A T H } / A n d r o i d / a n d r o i d - s d k / t o o l s / "
" / o p t / a n d r o i d - s d k / t o o l s / "
" / o p t / a n d r o i d - s d k - l i n u x _ x 8 6 / t o o l s / "
" / o p t / a n d r o i d - s d k - m a c _ x 8 6 / t o o l s / "
" / o p t / a n d r o i d - s d k - l i n u x _ 8 6 / t o o l s / "
" / o p t / a n d r o i d - s d k - m a c _ 8 6 / t o o l s / "
)
if ( ANDROID_EXECUTABLE )
message ( STATUS " Found android tool: ${ANDROID_EXECUTABLE}" )
endif ( )
endif ( )
#find apache ant
find_host_program ( ANT_EXECUTABLE NAMES ant.bat ant
P A T H S " $ { A N T _ D I R _ E N V _ P A T H } / b i n "
" $ { P r o g r a m F i l e s _ E N V _ P A T H } / a p a c h e - a n t / b i n "
)
if ( ANT_EXECUTABLE )
execute_process ( COMMAND ${ ANT_EXECUTABLE } -version
O U T P U T _ V A R I A B L E A N T _ V E R S I O N _ F U L L
O U T P U T _ S T R I P _ T R A I L I N G _ W H I T E S P A C E )
string ( REGEX MATCH "[0-9]+.[0-9]+.[0-9]+" ANT_VERSION "${ANT_VERSION_FULL}" )
message ( STATUS " Found apache ant ${ANT_VERSION}: ${ANT_EXECUTABLE}" )
endif ( )
if ( ANDROID_EXECUTABLE AND ANT_EXECUTABLE AND ( ANT_VERSION VERSION_GREATER 1.7.-1 ) )
SET ( CAN_BUILD_ANDROID_PROJECTS TRUE )
else ( )
SET ( CAN_BUILD_ANDROID_PROJECTS FALSE )
endif ( )
endif ( )
#YV
############################### QT ################################
set ( WITH_QT OFF CACHE BOOL "Build with Qt Backend support" )
set ( WITH_QT_OPENGL OFF CACHE BOOL "Add OpenGL extension to Qt" )
set ( HAVE_QT 0 )
set ( HAVE_QT_OPENGL 0 )
if ( WITH_QT )
find_package ( Qt4 )
if ( QT4_FOUND )
set ( HAVE_QT 1 )
add_definitions ( -DHAVE_QT ) #We need to define te macro this way, using cvconfig.h.cmake does not work
find_package ( OpenGL QUIET )
#if (NOT WIN32)
if ( WITH_QT_OPENGL )
if ( QT_QTOPENGL_FOUND AND OPENGL_FOUND )
set ( HAVE_QT_OPENGL 1 )
add_definitions ( -DHAVE_QT_OPENGL )
#link_directories("${OPENGL_LIBRARIES}")
set ( OPENCV_LINKER_LIBS ${ OPENCV_LINKER_LIBS } ${ OPENGL_LIBRARIES } )
endif ( )
endif ( )
#endif()
endif ( )
endif ( )
############################### TBB ################################
if ( WITH_TBB )
if ( UNIX AND NOT APPLE AND NOT ANDROID )
PKG_CHECK_MODULES ( TBB tbb )
message ( STATUS "TBB detected: ${TBBLIB_FOUND}" )
if ( TBB_FOUND )
set ( HAVE_TBB 1 )
if ( NOT ${ TBB_INCLUDE_DIRS } STREQUAL "" )
include_directories ( ${ TBB_INCLUDE_DIRS } )
endif ( )
link_directories ( ${ TBB_LIBRARY_DIRS } )
set ( OPENCV_LINKER_LIBS ${ OPENCV_LINKER_LIBS } ${ TBB_LIBRARIES } )
endif ( )
endif ( )
if ( NOT HAVE_TBB )
set ( TBB_DEFAULT_INCLUDE_DIRS "/opt/intel/tbb" "/usr/local/include" "/usr/include" "C:/Program Files/Intel/TBB" "C:/Program Files (x86)/Intel/TBB" "C:/Program Files (x86)/TBB" "${CMAKE_INSTALL_PREFIX}/include" )
find_path ( TBB_INCLUDE_DIR "tbb/tbb.h" PATHS ${ TBB_DEFAULT_INCLUDE_DIRS } DOC "The path to TBB headers" )
if ( TBB_INCLUDE_DIR )
if ( UNIX )
set ( TBB_LIB_DIR "${TBB_INCLUDE_DIR}/../lib" CACHE PATH "Full path of TBB library directory" )
link_directories ( "${TBB_LIB_DIR}" )
endif ( )
if ( APPLE )
set ( OPENCV_LINKER_LIBS ${ OPENCV_LINKER_LIBS } libtbb.dylib )
elseif ( ANDROID )
set ( OPENCV_LINKER_LIBS ${ OPENCV_LINKER_LIBS } tbbmalloc tbb )
add_definitions ( -DTBB_USE_GCC_BUILTINS )
elseif ( UNIX )
set ( OPENCV_LINKER_LIBS ${ OPENCV_LINKER_LIBS } tbb )
elseif ( WIN32 )
if ( CMAKE_COMPILER_IS_GNUCXX )
set ( TBB_LIB_DIR "${TBB_INCLUDE_DIR}/../lib" CACHE PATH "Full path of TBB library directory" )
link_directories ( "${TBB_LIB_DIR}" )
set ( OPENCV_LINKER_LIBS ${ OPENCV_LINKER_LIBS } tbb )
else ( )
get_filename_component ( _TBB_LIB_PATH "${TBB_INCLUDE_DIR}/../lib" ABSOLUTE )
if ( ${ CMAKE_SYSTEM_PROCESSOR } MATCHES amd64*|x86_64* )
set ( _TBB_LIB_PATH "${_TBB_LIB_PATH}/intel64" )
endif ( )
if ( ${ CMAKE_SYSTEM_PROCESSOR } MATCHES x86*|i386*|i686* )
set ( _TBB_LIB_PATH "${_TBB_LIB_PATH}/ia32" )
endif ( )
if ( MSVC80 )
set ( _TBB_LIB_PATH "${_TBB_LIB_PATH}/vc8" )
elseif ( MSVC90 )
set ( _TBB_LIB_PATH "${_TBB_LIB_PATH}/vc9" )
elseif ( MSVC10 )
set ( _TBB_LIB_PATH "${_TBB_LIB_PATH}/vc10" )
endif ( )
set ( TBB_LIB_DIR "${_TBB_LIB_PATH}" CACHE PATH "Full path of TBB library directory" )
link_directories ( "${TBB_LIB_DIR}" )
endif ( )
endif ( )
set ( HAVE_TBB 1 )
if ( NOT "${TBB_INCLUDE_DIR}" STREQUAL "" )
include_directories ( "${TBB_INCLUDE_DIR}" )
endif ( )
endif ( )
endif ( )
endif ( WITH_TBB )
#Threading Framework -- temporary decision for ARM-s instead of TBB
if ( NOT HAVE_TBB )
file ( GLOB THREADING_FRAMEWORK_HEADER "${OpenCV_SOURCE_DIR}/modules/core/include/opencv2/core/threading_framework.hpp" )
file ( GLOB THREADING_FRAMEWORK_SOURCE "${OpenCV_SOURCE_DIR}/modules/core/src/threading_framework.cpp" )
if ( THREADING_FRAMEWORK_HEADER AND THREADING_FRAMEWORK_SOURCE )
set ( HAVE_THREADING_FRAMEWORK 1 )
endif ( )
endif ( )
############################ Intel IPP #############################
set ( IPP_FOUND )
if ( WITH_IPP )
include ( OpenCVFindIPP.cmake )
endif ( )
if ( IPP_FOUND )
add_definitions ( -DHAVE_IPP )
include_directories ( ${ IPP_INCLUDE_DIRS } )
link_directories ( ${ IPP_LIBRARY_DIRS } )
set ( OPENCV_LINKER_LIBS ${ OPENCV_LINKER_LIBS } ${ IPP_LIBRARIES } )
endif ( )
############################### CUDA ################################
if ( WITH_CUDA )
find_package ( CUDA 4.0 )
if ( CUDA_FOUND )
set ( HAVE_CUDA 1 )
message ( STATUS "CUDA detected: " ${ CUDA_VERSION } )
set ( CUDA_ARCH_BIN "1.1 1.2 1.3 2.0 2.1(2.0)" CACHE STRING "Specify 'real' GPU architectures to build binaries for, BIN(PTX) format is supported" )
set ( CUDA_ARCH_PTX "2.0" CACHE STRING "Specify 'virtual' PTX architectures to build PTX intermediate code for" )
string ( REGEX REPLACE "\\." "" ARCH_BIN_NO_POINTS "${CUDA_ARCH_BIN}" )
string ( REGEX REPLACE "\\." "" ARCH_PTX_NO_POINTS "${CUDA_ARCH_PTX}" )
# Ckeck if user specified 1.0 compute capability: we don't support it
string ( REGEX MATCH "1.0" HAS_ARCH_10 "${CUDA_ARCH_BIN} ${CUDA_ARCH_PTX}" )
set ( CUDA_ARCH_BIN_OR_PTX_10 0 )
if ( NOT ${ HAS_ARCH_10 } STREQUAL "" )
set ( CUDA_ARCH_BIN_OR_PTX_10 1 )
endif ( )
# NVCC flags to be set
set ( NVCC_FLAGS_EXTRA "" )
# These vars will be passed into the templates
set ( OPENCV_CUDA_ARCH_BIN "" )
set ( OPENCV_CUDA_ARCH_PTX "" )
set ( OPENCV_CUDA_ARCH_FEATURES "" )
# Tell NVCC to add binaries for the specified GPUs
string ( REGEX MATCHALL "[0-9()]+" ARCH_LIST "${ARCH_BIN_NO_POINTS}" )
foreach ( ARCH IN LISTS ARCH_LIST )
if ( ARCH MATCHES "([0-9]+)\\(([0-9]+)\\)" )
# User explicitly specified PTX for the concrete BIN
set ( NVCC_FLAGS_EXTRA ${ NVCC_FLAGS_EXTRA } -gencode arch=compute_ ${ CMAKE_MATCH_2 } ,code=sm_ ${ CMAKE_MATCH_1 } )
set ( OPENCV_CUDA_ARCH_BIN "${OPENCV_CUDA_ARCH_BIN} ${CMAKE_MATCH_1}" )
set ( OPENCV_CUDA_ARCH_FEATURES "${OPENCV_CUDA_ARCH_FEATURES} ${CMAKE_MATCH_2}" )
else ( )
# User didn't explicitly specify PTX for the concrete BIN, we assume PTX=BIN
set ( NVCC_FLAGS_EXTRA ${ NVCC_FLAGS_EXTRA } -gencode arch=compute_ ${ ARCH } ,code=sm_ ${ ARCH } )
set ( OPENCV_CUDA_ARCH_BIN "${OPENCV_CUDA_ARCH_BIN} ${ARCH}" )
set ( OPENCV_CUDA_ARCH_FEATURES "${OPENCV_CUDA_ARCH_FEATURES} ${ARCH}" )
endif ( )
endforeach ( )
# Tell NVCC to add PTX intermediate code for the specified architectures
string ( REGEX MATCHALL "[0-9]+" ARCH_LIST "${ARCH_PTX_NO_POINTS}" )
foreach ( ARCH IN LISTS ARCH_LIST )
set ( NVCC_FLAGS_EXTRA ${ NVCC_FLAGS_EXTRA } -gencode arch=compute_ ${ ARCH } ,code=compute_ ${ ARCH } )
set ( OPENCV_CUDA_ARCH_PTX "${OPENCV_CUDA_ARCH_PTX} ${ARCH}" )
set ( OPENCV_CUDA_ARCH_FEATURES "${OPENCV_CUDA_ARCH_FEATURES} ${ARCH}" )
endforeach ( )
# These vars will be processed in other scripts
set ( CUDA_NVCC_FLAGS ${ CUDA_NVCC_FLAGS } ${ NVCC_FLAGS_EXTRA } )
set ( OpenCV_CUDA_CC "${NVCC_FLAGS_EXTRA}" )
message ( STATUS "CUDA NVCC target flags: ${CUDA_NVCC_FLAGS}" )
else ( )
unset ( CUDA_ARCH_BIN CACHE )
unset ( CUDA_ARCH_PTX CACHE )
endif ( )
endif ( )
############################### OpenNI ################################
set ( HAVE_OPENNI FALSE )
set ( HAVE_OPENNI_PRIME_SENSOR_MODULE FALSE )
if ( WITH_OPENNI )
include ( OpenCVFindOpenNI.cmake )
endif ( )
############################## Eigen ##############################
if ( WITH_EIGEN )
find_path ( EIGEN_INCLUDE_PATH "Eigen/Core"
P A T H S " / u s r / l o c a l / i n c l u d e / e i g e n 2 " " / o p t / i n c l u d e / e i g e n 2 " " / u s r / i n c l u d e / e i g e n 2 "
" / u s r / l o c a l / i n c l u d e / e i g e n 3 " " / o p t / i n c l u d e / e i g e n 3 " " / u s r / i n c l u d e / e i g e n 3 "
D O C " T h e p a t h t o E i g e n 2 / E i g e n 3 h e a d e r s " )
if ( EIGEN_INCLUDE_PATH )
include_directories ( ${ EIGEN_INCLUDE_PATH } )
set ( HAVE_EIGEN 1 )
endif ( )
endif ( )
################## Extra HighGUI libs on Windows ###################
if ( WIN32 )
set ( WITH_VIDEOINPUT ON CACHE BOOL "Build HighGUI with DirectShow support" )
set ( HIGHGUI_LIBRARIES ${ HIGHGUI_LIBRARIES } comctl32 gdi32 ole32 )
if ( WITH_VIDEOINPUT )
set ( HAVE_VIDEOINPUT 1 )
set ( HIGHGUI_LIBRARIES ${ HIGHGUI_LIBRARIES } strmiids )
endif ( )
if ( MSVC )
set ( HIGHGUI_LIBRARIES ${ HIGHGUI_LIBRARIES } vfw32 )
endif ( )
if ( MINGW )
if ( MINGW64 )
set ( HIGHGUI_LIBRARIES ${ HIGHGUI_LIBRARIES } msvfw32 avifil32 avicap32 winmm )
else ( )
set ( HIGHGUI_LIBRARIES ${ HIGHGUI_LIBRARIES } vfw32 winmm )
endif ( )
endif ( )
endif ( )
############## Android source tree for native camera ###############
if ( ANDROID )
SET ( ANDROID_SOURCE_TREE "ANDROID_SOURCE_TREE-NOTFOUND" CACHE PATH
" P a t h t o A n d r o i d s o u r c e t r e e .
S e t t h i s v a r i a b l e t o p a t h t o y o u r A n d r o i d s o u r c e s t o c o m p i l e
l i b n a t i v e _ c a m e r a _ r x . x . x . s o f o r y o u r A n d r o i d " )
SET ( BUILD_ANDROID_CAMERA_WRAPPER OFF )
if ( ANDROID_SOURCE_TREE )
FILE ( STRINGS "${ANDROID_SOURCE_TREE}/development/sdk/platform_source.properties" ANDROID_VERSION REGEX "Platform\\.Version=[0-9]+\\.[0-9]+\\.[0-9]+" )
string ( REGEX REPLACE "Platform\\.Version=([0-9]+\\.[0-9]+\\.[0-9]+)" "\\1" ANDROID_VERSION "${ANDROID_VERSION}" )
if ( NOT "${ANDROID_VERSION}" STREQUAL "" )
SET ( BUILD_ANDROID_CAMERA_WRAPPER ON )
endif ( )
endif ( )
endif ( )
# ----------------------------------------------------------------------------
# UPDATE CONFIG FILES & SCRIPTS:
#
# CONFIGURE_FILE(InputFile OutputFile [COPYONLY] [ESCAPE_QUOTES] [@ONLY])
# If @ONLY is specified, only variables of the form @VAR@ will be
# replaces and ${VAR} will be ignored.
#
# A directory will be created for each platform so the "cvconfig.h" file is
# not overwritten if cmake generates code in the same path.
# ----------------------------------------------------------------------------
add_definitions ( -DHAVE_CVCONFIG_H )
set ( OPENCV_CONFIG_FILE_INCLUDE_DIR "${CMAKE_BINARY_DIR}/" CACHE PATH "Where to create the platform-dependant cvconfig.h" )
message ( STATUS "Parsing 'cvconfig.h.cmake'" )
configure_file ( "${CMAKE_CURRENT_SOURCE_DIR}/cvconfig.h.cmake" "${OPENCV_CONFIG_FILE_INCLUDE_DIR}/cvconfig.h" )
# ---------------------------------------------------------------------------
# The C+//0 include & link directories:
# ---------------------------------------------------------------------------
include_directories ( "."
" $ { O P E N C V _ C O N F I G _ F I L E _ I N C L U D E _ D I R } "
" $ { C M A K E _ C U R R E N T _ S O U R C E _ D I R } / i n c l u d e "
" $ { C M A K E _ C U R R E N T _ S O U R C E _ D I R } / i n c l u d e / o p e n c v "
)
# ----------------------------------------------------------------------------
# Set the maximum level of warnings:
# ----------------------------------------------------------------------------
# Should be set to true for development
set ( OPENCV_WARNINGS_ARE_ERRORS OFF CACHE BOOL "Treat warnings as errors" )
if ( WIN32 AND ${ CMAKE_GENERATOR } MATCHES "(MinGW)|(MSYS)" )
set ( CMAKE_CXX_FLAGS_RELEASE "-O2 -DNDEBUG" CACHE STRING "" )
endif ( )
set ( EXTRA_C_FLAGS "" )
set ( EXTRA_C_FLAGS_RELEASE "" )
set ( EXTRA_C_FLAGS_DEBUG "" )
set ( EXTRA_EXE_LINKER_FLAGS "" )
set ( EXTRA_EXE_LINKER_FLAGS_RELEASE "" )
set ( EXTRA_EXE_LINKER_FLAGS_DEBUG "" )
if ( MSVC )
set ( EXTRA_C_FLAGS "${EXTRA_C_FLAGS} /D _CRT_SECURE_NO_DEPRECATE /D _CRT_NONSTDC_NO_DEPRECATE /D _SCL_SECURE_NO_WARNINGS" )
# 64-bit portability warnings, in MSVC8
if ( MSVC80 )
set ( EXTRA_C_FLAGS "${EXTRA_C_FLAGS} /Wp64" )
endif ( )
#if(MSVC90)
# set(EXTRA_C_FLAGS "${EXTRA_C_FLAGS} /D _BIND_TO_CURRENT_CRT_VERSION=1 /D _BIND_TO_CURRENT_VCLIBS_VERSION=1")
#endif()
set ( EXTRA_EXE_LINKER_FLAGS_RELEASE "${EXTRA_EXE_LINKER_FLAGS_RELEASE} /debug" )
# Remove unreferenced functions: function level linking
set ( EXTRA_C_FLAGS "${EXTRA_C_FLAGS} /Gy" )
set ( EXTRA_C_FLAGS_RELEASE "${EXTRA_C_FLAGS_RELEASE} /Zi" )
endif ( )
if ( CMAKE_COMPILER_IS_GNUCXX )
# High level of warnings.
set ( EXTRA_C_FLAGS "${EXTRA_C_FLAGS} -Wall" )
# The -Wno-long-long is required in 64bit systems when including sytem headers.
if ( ${ CMAKE_SYSTEM_PROCESSOR } MATCHES x86_64* )
set ( EXTRA_C_FLAGS "${EXTRA_C_FLAGS} -Wno-long-long" )
endif ( )
if ( ${ CMAKE_SYSTEM_PROCESSOR } MATCHES amd64* )
set ( EXTRA_C_FLAGS "${EXTRA_C_FLAGS} -Wno-long-long" )
endif ( )
# We need pthread's
if ( UNIX AND NOT ANDROID )
set ( EXTRA_C_FLAGS "${EXTRA_C_FLAGS} -pthread" )
endif ( )
if ( OPENCV_WARNINGS_ARE_ERRORS )
set ( EXTRA_C_FLAGS "${EXTRA_C_FLAGS} -Werror" )
endif ( )
if ( X86 AND NOT MINGW64 AND NOT X86_64 AND NOT APPLE )
set ( EXTRA_C_FLAGS "${EXTRA_C_FLAGS} -march=i686" )
endif ( )
# Other optimizations
if ( USE_OMIT_FRAME_POINTER )
set ( EXTRA_C_FLAGS_RELEASE "${EXTRA_C_FLAGS_RELEASE} -fomit-frame-pointer" )
endif ( )
if ( USE_FAST_MATH )
set ( EXTRA_C_FLAGS_RELEASE "${EXTRA_C_FLAGS_RELEASE} -ffast-math" )
endif ( )
if ( ENABLE_POWERPC )
set ( EXTRA_C_FLAGS_RELEASE "${EXTRA_C_FLAGS_RELEASE} -mcpu=G3 -mtune=G5" )
endif ( )
if ( ENABLE_SSE )
set ( EXTRA_C_FLAGS_RELEASE "${EXTRA_C_FLAGS_RELEASE} -msse" )
endif ( )
if ( ENABLE_SSE2 )
set ( EXTRA_C_FLAGS_RELEASE "${EXTRA_C_FLAGS_RELEASE} -msse2" )
endif ( )
# SSE3 and further should be disabled under MingW because it generates compiler errors
if ( NOT MINGW )
if ( ENABLE_SSE3 )
set ( EXTRA_C_FLAGS_RELEASE "${EXTRA_C_FLAGS_RELEASE} -msse3" )
endif ( )
if ( ${ CMAKE_OPENCV_GCC_VERSION_NUM } GREATER 402 )
set ( HAVE_GCC43_OR_NEWER 1 )
endif ( )
if ( ${ CMAKE_OPENCV_GCC_VERSION_NUM } GREATER 401 )
set ( HAVE_GCC42_OR_NEWER 1 )
endif ( )
if ( HAVE_GCC43_OR_NEWER OR APPLE )
if ( ENABLE_SSSE3 )
set ( EXTRA_C_FLAGS_RELEASE "${EXTRA_C_FLAGS_RELEASE} -mssse3" )
endif ( )
if ( HAVE_GCC42_OR_NEWER )
if ( ENABLE_SSE41 )
set ( EXTRA_C_FLAGS_RELEASE "${EXTRA_C_FLAGS_RELEASE} -msse4.1" )
endif ( )
if ( ENABLE_SSE42 )
set ( EXTRA_C_FLAGS_RELEASE "${EXTRA_C_FLAGS_RELEASE} -msse4.2" )
endif ( )
endif ( )
endif ( )
endif ( )
if ( X86 OR X86_64 )
if ( NOT APPLE AND ${ CMAKE_SIZEOF_VOID_P } EQUAL 4 )
set ( EXTRA_C_FLAGS_RELEASE "${EXTRA_C_FLAGS_RELEASE} -mfpmath=387" )
endif ( )
endif ( )
# Profiling?
if ( ENABLE_PROFILING )
set ( EXTRA_C_FLAGS_RELEASE "${EXTRA_C_FLAGS_RELEASE} -pg -g" )
elseif ( NOT APPLE )
# Remove unreferenced functions: function level linking
set ( EXTRA_C_FLAGS "${EXTRA_C_FLAGS} -ffunction-sections" )
endif ( )
set ( EXTRA_C_FLAGS_RELEASE "${EXTRA_C_FLAGS_RELEASE} -DNDEBUG" )
set ( EXTRA_C_FLAGS_DEBUG "${EXTRA_C_FLAGS_DEBUG} -O0 -ggdb3 -DDEBUG -D_DEBUG" )
endif ( )
if ( MSVC )
if ( ENABLE_SSE )
set ( EXTRA_C_FLAGS_RELEASE "${EXTRA_C_FLAGS_RELEASE} /arch:SSE" )
endif ( )
if ( ENABLE_SSE2 )
set ( EXTRA_C_FLAGS_RELEASE "${EXTRA_C_FLAGS_RELEASE} /arch:SSE2" )
endif ( )
if ( ENABLE_SSE3 )
set ( EXTRA_C_FLAGS_RELEASE "${EXTRA_C_FLAGS_RELEASE} /arch:SSE3" )
endif ( )
if ( ENABLE_SSE4_1 )
set ( EXTRA_C_FLAGS_RELEASE "${EXTRA_C_FLAGS_RELEASE} /arch:SSE4.1" )
endif ( )
if ( ENABLE_SSE OR ENABLE_SSE2 OR ENABLE_SSE3 OR ENABLE_SSE4_1 )
set ( EXTRA_C_FLAGS_RELEASE "${EXTRA_C_FLAGS_RELEASE} /Oi" )
endif ( )
endif ( )
# Extra link libs if the user selects building static libs:
if ( NOT BUILD_SHARED_LIBS AND CMAKE_COMPILER_IS_GNUCXX AND NOT ANDROID )
# Android does not need these settings because they are already set by toolchain file
set ( OPENCV_LINKER_LIBS ${ OPENCV_LINKER_LIBS } stdc++ )
set ( OPENCV_EXTRA_C_FLAGS "-fPIC ${OPENCV_EXTRA_C_FLAGS}" )
endif ( )
# Add user supplied extra options (optimization, etc...)
# ==========================================================
set ( OPENCV_EXTRA_C_FLAGS "${OPENCV_EXTRA_C_FLAGS}" CACHE STRING "Extra compiler options" )
set ( OPENCV_EXTRA_C_FLAGS_RELEASE "${OPENCV_EXTRA_C_FLAGS_RELEASE}" CACHE STRING "Extra compiler options for Release build" )
set ( OPENCV_EXTRA_C_FLAGS_DEBUG "${OPENCV_EXTRA_C_FLAGS_DEBUG}" CACHE STRING "Extra compiler options for Debug build" )
set ( OPENCV_EXTRA_EXE_LINKER_FLAGS "${OPENCV_EXTRA_EXE_LINKER_FLAGS}" CACHE STRING "Extra linker flags" FORCE )
set ( OPENCV_EXTRA_EXE_LINKER_FLAGS_RELEASE "${OPENCV_EXTRA_EXE_LINKER_FLAGS_RELEASE}" CACHE STRING "Extra linker flags for Release build" FORCE )
set ( OPENCV_EXTRA_EXE_LINKER_FLAGS_DEBUG "${OPENCV_EXTRA_EXE_LINKER_FLAGS_DEBUG}" CACHE STRING "Extra linker flags for Debug build" FORCE )
#combine all "extra" options
set ( CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${EXTRA_C_FLAGS} ${OPENCV_EXTRA_C_FLAGS}" )
set ( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${EXTRA_C_FLAGS} ${OPENCV_EXTRA_C_FLAGS}" )
set ( CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} ${EXTRA_C_FLAGS_RELEASE} ${OPENCV_EXTRA_C_FLAGS_RELEASE}" )
set ( CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} ${EXTRA_C_FLAGS_RELEASE} ${OPENCV_EXTRA_C_FLAGS_RELEASE}" )
set ( CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} ${EXTRA_C_FLAGS_DEBUG} ${OPENCV_EXTRA_C_FLAGS_DEBUG}" )
set ( CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} ${EXTRA_C_FLAGS_DEBUG} ${OPENCV_EXTRA_C_FLAGS_DEBUG}" )
set ( CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${EXTRA_EXE_LINKER_FLAGS} ${OPENCV_EXTRA_EXE_LINKER_FLAGS}" )
set ( CMAKE_EXE_LINKER_FLAGS_RELEASE "${CMAKE_EXE_LINKER_FLAGS_RELEASE} ${EXTRA_EXE_LINKER_FLAGS_RELEASE} ${OPENCV_EXTRA_EXE_LINKER_FLAGS_RELEASE}" )
set ( CMAKE_EXE_LINKER_FLAGS_DEBUG "${CMAKE_EXE_LINKER_FLAGS_DEBUG} ${EXTRA_EXE_LINKER_FLAGS_DEBUG} ${OPENCV_EXTRA_EXE_LINKER_FLAGS_DEBUG}" )
# In case of Makefiles if the user does not setup CMAKE_BUILD_TYPE, assume it's Release:
if ( ${ CMAKE_GENERATOR } MATCHES ".*Makefiles" AND "${CMAKE_BUILD_TYPE}" STREQUAL "" )
set ( CMAKE_BUILD_TYPE Release )
endif ( )
if ( WIN32 AND MSVC )
# avoid warnings from MSVC about overriding the /W* option
# we replace /W3 with /W4 only for C++ files,
# since all the 3rd-party libraries OpenCV uses are in C,
# and we do not care about their warnings.
string ( REPLACE "/W3" "/W4" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}" )
string ( REPLACE "/W3" "/W4" CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE}" )
string ( REPLACE "/W3" "/W4" CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG}" )
# allow extern "C" functions throw exceptions
string ( REPLACE "/EHsc" "/EHsc-" CMAKE_C_FLAGS "${CMAKE_C_FLAGS}" )
string ( REPLACE "/EHsc" "/EHsc-" CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE}" )
string ( REPLACE "/EHsc" "/EHsc-" CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG}" )
string ( REPLACE "/EHsc" "/EHsc-" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}" )
string ( REPLACE "/EHsc" "/EHsc-" CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE}" )
string ( REPLACE "/EHsc" "/EHsc-" CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG}" )
string ( REPLACE "/Zm1000" " " CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}" )
string ( REPLACE "/Zm1000" " " CMAKE_C_FLAGS "${CMAKE_C_FLAGS}" )
endif ( )
if ( "${CMAKE_CONFIGURE_LDFLAGS}" )
set ( CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${CMAKE_CONFIGURE_LDFLAGS}" )
endif ( "${CMAKE_CONFIGURE_LDFLAGS}" )
# --------------------------------------------------------------------------------------------
# Installation for CMake Module: OpenCVConfig.cmake
# Part 1/3: ${BIN_DIR}/OpenCVConfig.cmake -> For use *without* "make install"
# Part 2/3: ${BIN_DIR}/unix-install/OpenCVConfig.cmake -> For use with "make install"
# Part 3/3: ${BIN_DIR}/win-install/OpenCVConfig.cmake -> For use within binary installers/packages
# -------------------------------------------------------------------------------------------
# -------------------------------------------------------------------------------------------
# Part 1/3: ${BIN_DIR}/OpenCVConfig.cmake -> For use *without* "make install"
# -------------------------------------------------------------------------------------------
set ( CMAKE_INCLUDE_DIRS_CONFIGCMAKE "\" ${ OPENCV_CONFIG_FILE_INCLUDE_DIR } \" \"${CMAKE_CURRENT_SOURCE_DIR}/include\" \"${CMAKE_CURRENT_SOURCE_DIR}/include/opencv\"")
set ( CMAKE_OPENCV2_INCLUDE_DIRS_CONFIGCMAKE "${CMAKE_CURRENT_SOURCE_DIR}" )
set ( CMAKE_LIB_DIRS_CONFIGCMAKE "${LIBRARY_OUTPUT_PATH}" )
set ( CMAKE_3RDPARTY_LIB_DIRS_CONFIGCMAKE "\" ${ CMAKE_BINARY_DIR } /3rdparty/ ${ OPENCV_LIB_INSTALL_PATH } \"")
configure_file ( "${CMAKE_CURRENT_SOURCE_DIR}/OpenCVConfig.cmake.in" "${CMAKE_BINARY_DIR}/OpenCVConfig.cmake" IMMEDIATE @ONLY )
#support for version checking when finding opencv. find_package(OpenCV 2.3.1 EXACT) should now work.
configure_file ( "${CMAKE_CURRENT_SOURCE_DIR}/OpenCVConfig-version.cmake.in" "${CMAKE_BINARY_DIR}/OpenCVConfig-version.cmake" IMMEDIATE @ONLY )
# --------------------------------------------------------------------------------------------
# Part 2/3: ${BIN_DIR}/unix-install/OpenCVConfig.cmake -> For use *with* "make install"
# -------------------------------------------------------------------------------------------
set ( CMAKE_INCLUDE_DIRS_CONFIGCMAKE "\" \${OpenCV_INSTALL_PATH}/${OPENCV_INCLUDE_PREFIX}/opencv" "\${OpenCV_INSTALL_PATH}/${OPENCV_INCLUDE_PREFIX}\" " )
set ( CMAKE_OPENCV2_INCLUDE_DIRS_CONFIGCMAKE "" )
if ( ANDROID )
set ( CMAKE_LIB_DIRS_CONFIGCMAKE "\" \${OpenCV_INSTALL_PATH}/libs/\${ARMEABI_NDK_NAME}\"")
set ( CMAKE_3RDPARTY_LIB_DIRS_CONFIGCMAKE "\" \${OpenCV_INSTALL_PATH}/share/OpenCV/3rdparty/libs/\${ARMEABI_NDK_NAME}\"")
else ( )
set ( CMAKE_LIB_DIRS_CONFIGCMAKE "\" \${OpenCV_INSTALL_PATH}/${OPENCV_LIB_INSTALL_PATH}\"")
set ( CMAKE_3RDPARTY_LIB_DIRS_CONFIGCMAKE "\" \${OpenCV_INSTALL_PATH}/share/OpenCV/3rdparty/${OPENCV_LIB_INSTALL_PATH}\"")
if ( OPENCV_MANGLED_INSTALL_PATHS )
set ( CMAKE_3RDPARTY_LIB_DIRS_CONFIGCMAKE "\" \${OpenCV_INSTALL_PATH}/share/OpenCV-${OPENCV_VERSION}/3rdparty/${OPENCV_LIB_INSTALL_PATH}\"")
endif ( )
endif ( )
configure_file ( "${CMAKE_CURRENT_SOURCE_DIR}/OpenCVConfig.cmake.in" "${CMAKE_BINARY_DIR}/unix-install/OpenCVConfig.cmake" IMMEDIATE @ONLY )
configure_file ( "${CMAKE_CURRENT_SOURCE_DIR}/OpenCVConfig-version.cmake.in" "${CMAKE_BINARY_DIR}/unix-install/OpenCVConfig-version.cmake" IMMEDIATE @ONLY )
if ( UNIX )
#http://www.vtk.org/Wiki/CMake/Tutorials/Packaging reference
# For a command "find_package(<name> [major[.minor]] [EXACT] [REQUIRED|QUIET])"
# cmake will look in the following dir on unix:
# <prefix>/(share|lib)/cmake/<name>*/ (U)
# <prefix>/(share|lib)/<name>*/ (U)
# <prefix>/(share|lib)/<name>*/(cmake|CMake)/ (U)
if ( OPENCV_MANGLED_INSTALL_PATHS )
install ( FILES ${ CMAKE_BINARY_DIR } /unix-install/OpenCVConfig.cmake DESTINATION share/OpenCV- ${ OPENCV_VERSION } / )
install ( FILES ${ CMAKE_BINARY_DIR } /unix-install/OpenCVConfig-version.cmake DESTINATION share/OpenCV- ${ OPENCV_VERSION } / )
else ( )
install ( FILES "${CMAKE_BINARY_DIR}/unix-install/OpenCVConfig.cmake" DESTINATION share/OpenCV/ )
install ( FILES ${ CMAKE_BINARY_DIR } /unix-install/OpenCVConfig-version.cmake DESTINATION share/OpenCV/ )
endif ( )
endif ( )
if ( ANDROID )
install ( FILES "${CMAKE_CURRENT_SOURCE_DIR}/android/android.toolchain.cmake" DESTINATION share/OpenCV )
endif ( )
# --------------------------------------------------------------------------------------------
# Part 3/3: ${BIN_DIR}/win-install/OpenCVConfig.cmake -> For use within binary installers/packages
# -------------------------------------------------------------------------------------------
if ( WIN32 )
set ( CMAKE_INCLUDE_DIRS_CONFIGCMAKE "\" \${OpenCV_CONFIG_PATH}/include\" \"\${OpenCV_CONFIG_PATH}/include/opencv\"")
set ( CMAKE_OPENCV2_INCLUDE_DIRS_CONFIGCMAKE "" )
set ( CMAKE_LIB_DIRS_CONFIGCMAKE "\" \${OpenCV_CONFIG_PATH}/${OPENCV_LIB_INSTALL_PATH}\"")
set ( CMAKE_3RDPARTY_LIB_DIRS_CONFIGCMAKE "\" \${OpenCV_CONFIG_PATH}/share/OpenCV/3rdparty/${OPENCV_LIB_INSTALL_PATH}\"")
exec_program ( mkdir ARGS "-p \" ${ CMAKE_BINARY_DIR } /win-install/\ "" OUTPUT_VARIABLE RET_VAL )
configure_file ( "${CMAKE_CURRENT_SOURCE_DIR}/OpenCVConfig.cmake.in" "${CMAKE_BINARY_DIR}/win-install/OpenCVConfig.cmake" IMMEDIATE @ONLY )
# Install the OpenCVConfig.cmake file which has the right paths pointing to the install directory
install ( FILES "${CMAKE_BINARY_DIR}/win-install/OpenCVConfig.cmake" DESTINATION "${CMAKE_INSTALL_PREFIX}/" )
endif ( )
# --------------------------------------------------------------------------------------------
# Installation for Android ndk-build makefile: OpenCV.mk
# Part 1/2: ${BIN_DIR}/OpenCV.mk -> For use *without* "make install"
# Part 2/2: ${BIN_DIR}/unix-install/OpenCV.mk -> For use with "make install"
# -------------------------------------------------------------------------------------------
if ( ANDROID )
if ( BUILD_SHARED_LIBS )
SET ( OPENCV_LIBTYPE_CONFIGMAKE "SHARED" )
else ( )
SET ( OPENCV_LIBTYPE_CONFIGMAKE "STATIC" )
endif ( )
if ( BUILD_ANDROID_CAMERA_WRAPPER )
set ( CMAKE_CAMERA_LIBS_CONFIGCMAKE "native_camera_r${ANDROID_VERSION}" )
else ( )
SET ( CMAKE_CAMERA_LIBS_CONFIGCMAKE "" )
file ( GLOB CMAKE_CAMERA_LIBS "${CMAKE_CURRENT_SOURCE_DIR}/3rdparty/lib/libnative_camera_r*.so" )
foreach ( cam_lib ${ CMAKE_CAMERA_LIBS } )
get_filename_component ( cam_lib "${cam_lib}" NAME )
string ( REGEX REPLACE "lib(native_camera_r[0-9]+\\.[0-9]+\\.[0-9]+)\\.so" "\\1" cam_lib "${cam_lib}" )
SET ( CMAKE_CAMERA_LIBS_CONFIGCMAKE "${CMAKE_CAMERA_LIBS_CONFIGCMAKE} ${cam_lib}" )
endforeach ( )
endif ( )
endif ( ANDROID )
# -------------------------------------------------------------------------------------------
# Part 1/2: ${BIN_DIR}/OpenCV.mk -> For use *without* "make install"
# -------------------------------------------------------------------------------------------
if ( ANDROID )
set ( CMAKE_INCLUDE_DIRS_CONFIGCMAKE "\" ${ OPENCV_CONFIG_FILE_INCLUDE_DIR } \" \"${CMAKE_CURRENT_SOURCE_DIR}/include\" \"${CMAKE_CURRENT_SOURCE_DIR}/include/opencv\"")
set ( CMAKE_BASE_INCLUDE_DIR_CONFIGCMAKE "\" ${ CMAKE_CURRENT_SOURCE_DIR } \"")
set ( CMAKE_LIBS_DIR_CONFIGCMAKE "\$(OPENCV_THIS_DIR)" )
configure_file ( "${CMAKE_CURRENT_SOURCE_DIR}/OpenCV.mk.in" "${CMAKE_BINARY_DIR}/OpenCV.mk" IMMEDIATE @ONLY )
endif ( ANDROID )
# -------------------------------------------------------------------------------------------
# Part 2/2: ${BIN_DIR}/unix-install/OpenCV.mk -> For use with "make install"
# -------------------------------------------------------------------------------------------
if ( ANDROID )
set ( CMAKE_INCLUDE_DIRS_CONFIGCMAKE "\" \$(LOCAL_PATH)/\$(OPENCV_THIS_DIR)/../../include/opencv\" \"\$(LOCAL_PATH)/\$(OPENCV_THIS_DIR)/../../include\"")
set ( CMAKE_BASE_INCLUDE_DIR_CONFIGCMAKE "" )
set ( CMAKE_LIBS_DIR_CONFIGCMAKE "\$(OPENCV_THIS_DIR)/../.." )
configure_file ( "${CMAKE_CURRENT_SOURCE_DIR}/OpenCV.mk.in" "${CMAKE_BINARY_DIR}/unix-install/OpenCV.mk" IMMEDIATE @ONLY )
install ( FILES ${ CMAKE_BINARY_DIR } /unix-install/OpenCV.mk DESTINATION share/OpenCV/ )
endif ( ANDROID )
# --------------------------------------------------------------------------------------------
#according to man pkg-config
# The package name specified on the pkg-config command line is defined to
# be the name of the metadata file, minus the .pc extension. If a library
# can install multiple versions simultaneously, it must give each version
# its own name (for example, GTK 1.2 might have the package name "gtk+"
# while GTK 2.0 has "gtk+-2.0").
# Part 2/2: ${BIN_DIR}/unix-install/opencv.pc -> For use *with* "make install"
# prefix=/usr
# exec_prefix=${prefix}
# libdir=${exec_prefix}/lib
# includedir=${prefix}/include/opencv
# -------------------------------------------------------------------------------------------
set ( prefix ${ CMAKE_INSTALL_PREFIX } )
set ( exec_prefix "\${prefix}" )
set ( libdir "\${exec_prefix}/lib" )
set ( includedir "\${prefix}/${OPENCV_INCLUDE_PREFIX}" )
set ( VERSION ${ OPENCV_VERSION } )
set ( OPENCV_PC_FILE_NAME opencv.pc )
#need to be explicit with naming the pc file and version number for side by side installs to work.
if ( OPENCV_MANGLED_INSTALL_PATHS )
SET ( OpenCV_LIB_COMPONENTS opencv_contrib opencv_legacy opencv_objdetect opencv_calib3d opencv_features2d opencv_video opencv_highgui opencv_ml opencv_imgproc opencv_flann opencv_core )
#be explicit about the library names.
set ( OpenCV_LIB_COMPONENTS_ )
foreach ( CVLib ${ OpenCV_LIB_COMPONENTS } )
set ( OpenCV_LIB_COMPONENTS_ "${OpenCV_LIB_COMPONENTS_} ${libdir}/lib${CVLib}.so.${OPENCV_VERSION}" )
endforeach ( )
set ( OpenCV_LIB_COMPONENTS ${ OpenCV_LIB_COMPONENTS_ } )
set ( OPENCV_PC_FILE_NAME "opencv-${OPENCV_VERSION}.pc" )
configure_file ( "${CMAKE_CURRENT_SOURCE_DIR}/opencv-XXX.pc.cmake.in" "${CMAKE_BINARY_DIR}/unix-install/${OPENCV_PC_FILE_NAME}" @ONLY IMMEDIATE )
else ( )
configure_file ( "${CMAKE_CURRENT_SOURCE_DIR}/opencv.pc.cmake.in" "${CMAKE_BINARY_DIR}/unix-install/${OPENCV_PC_FILE_NAME}" @ONLY IMMEDIATE )
endif ( )
if ( UNIX AND NOT ANDROID )
install ( FILES ${ CMAKE_BINARY_DIR } /unix-install/ ${ OPENCV_PC_FILE_NAME } DESTINATION ${ OPENCV_LIB_INSTALL_PATH } /pkgconfig )
endif ( )
# ----------------------------------------------------------------------------
# Uninstall target, for "make uninstall"
# ----------------------------------------------------------------------------
CONFIGURE_FILE (
" $ { C M A K E _ C U R R E N T _ S O U R C E _ D I R } / c m a k e _ u n i n s t a l l . c m a k e . i n "
" $ { C M A K E _ C U R R E N T _ B I N A R Y _ D I R } / c m a k e _ u n i n s t a l l . c m a k e "
I M M E D I A T E @ O N L Y )
ADD_CUSTOM_TARGET ( uninstall "${CMAKE_COMMAND}" -P "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake" )
# ----------------------------------------------------------------------------
# CPack target
# ----------------------------------------------------------------------------
set ( BUILD_PACKAGE OFF CACHE BOOL "Build a installer with the SDK" )
if ( BUILD_PACKAGE )
configure_file (
P a c k a g e . c m a k e . i n
$ { C M A K E _ B I N A R Y _ D I R } / . c p a c k / P a c k a g e . c m a k e
@ O N L Y
)
include ( ${ CMAKE_BINARY_DIR } /.cpack/Package.cmake )
set ( root_files README )
file ( GLOB root_src_files *.in *.cmake CMakeLists.txt )
if ( NOT WIN32 )
install ( FILES ${ root_files }
D E S T I N A T I O N $ { O P E N C V _ D O C _ I N S T A L L _ P A T H }
C O M P O N E N T m a i n )
else ( )
install ( FILES ${ root_files }
D E S T I N A T I O N " . "
C O M P O N E N T m a i n )
install ( FILES ${ root_src_files }
D E S T I N A T I O N " . "
C O M P O N E N T s r c )
# Add the "win-install/OpenCVConfig.cmake" file to the "main" install component
install ( FILES
" $ { C M A K E _ B I N A R Y _ D I R } / w i n - i n s t a l l / O p e n C V C o n f i g . c m a k e "
D E S T I N A T I O N " . "
C O M P O N E N T m a i n
)
install ( FILES
" i n c l u d e / C M a k e L i s t s . t x t "
D E S T I N A T I O N " i n c l u d e / "
C O M P O N E N T s r c
)
if ( CMAKE_INSTALL_DEBUG_LIBRARIES )
foreach ( m calib3d core contrib features2d ffmpeg flann gpu highgui imgproc legacy ml objdetect video )
install ( FILES ${ EXECUTABLE_OUTPUT_PATH } /Debug/opencv_ ${ m } ${ OPENCV_DLLVERSION } d.dll
D E S T I N A T I O N b i n C O M P O N E N T m a i n )
install ( FILES ${ LIBRARY_OUTPUT_PATH } /Debug/opencv_ ${ m } ${ OPENCV_DLLVERSION } d.lib
D E S T I N A T I O N l i b C O M P O N E N T m a i n )
endforeach ( )
endif ( )
install ( DIRECTORY data samples DESTINATION "." COMPONENT main PATTERN ".svn" EXCLUDE )
install ( DIRECTORY 3rdparty android modules doc DESTINATION "." COMPONENT src PATTERN ".svn" EXCLUDE )
#install(DIRECTORY doc DESTINATION doc COMPONENT src FILES_MATCHING PATTERN "*.rst" "*.tex")
#install(DIRECTORY doc/pics DESTINATION doc COMPONENT src PATTERN ".svn" EXCLUDE)
#install(DIRECTORY doc/latex2sphinx DESTINATION doc COMPONENT src PATTERN ".svn" EXCLUDE)
# install TBB dlls
if ( WIN32 AND HAVE_TBB )
string ( REGEX REPLACE "/lib" "/bin" TBB_DLL_DIR "${TBB_LIB_DIR}" )
install ( PROGRAMS "${TBB_DLL_DIR}/tbb.dll" DESTINATION bin COMPONENT main )
install ( PROGRAMS "${TBB_DLL_DIR}/tbb_debug.dll" DESTINATION bin COMPONENT main )
endif ( )
endif ( )
endif ( )
#-----------------------------------
# Solution folders:
#-----------------------------------
if ( ${ CMAKE_VERSION } VERSION_GREATER "2.8.0" )
set ( ENABLE_SOLUTION_FOLDERS OFF CACHE BOOL "Solution folder in Visual Studio or in other IDEs" )
endif ( )
if ( ENABLE_SOLUTION_FOLDERS )
set_property ( GLOBAL PROPERTY USE_FOLDERS ON )
set_property ( GLOBAL PROPERTY PREDEFINED_TARGETS_FOLDER "CMakeTargets" )
endif ( )
#-----------------------------------
# Subdirectories:
#-----------------------------------
add_subdirectory ( include )
add_subdirectory ( modules )
add_subdirectory ( doc )
add_subdirectory ( data )
add_subdirectory ( 3rdparty )
if ( BUILD_EXAMPLES OR INSTALL_PYTHON_EXAMPLES )
add_subdirectory ( samples )
endif ( )
# ----------------------------------------------------------------------------
# Summary:
# ----------------------------------------------------------------------------
message ( STATUS "" )
message ( STATUS "General configuration for opencv ${OPENCV_VERSION} =====================================" )
message ( STATUS "" )
message ( STATUS " Built as dynamic libs?: ${BUILD_SHARED_LIBS}" )
message ( STATUS " Compiler: ${CMAKE_COMPILER}" )
message ( STATUS " C++ flags (Release): ${CMAKE_CXX_FLAGS} ${CMAKE_CXX_FLAGS_RELEASE}" )
message ( STATUS " C++ flags (Debug): ${CMAKE_CXX_FLAGS} ${CMAKE_CXX_FLAGS_DEBUG}" )
if ( WIN32 )
message ( STATUS " Linker flags (Release): ${CMAKE_EXE_LINKER_FLAGS} ${CMAKE_EXE_LINKER_FLAGS_RELEASE}" )
message ( STATUS " Linker flags (Debug): ${CMAKE_EXE_LINKER_FLAGS} ${CMAKE_EXE_LINKER_FLAGS_DEBUG}" )
else ( )
message ( STATUS " Linker flags (Release): ${CMAKE_SHARED_LINKER_FLAGS} ${CMAKE_SHARED_LINKER_FLAGS_RELEASE}" )
message ( STATUS " Linker flags (Debug): ${CMAKE_SHARED_LINKER_FLAGS} ${CMAKE_SHARED_LINKER_FLAGS_DEBUG}" )
endif ( )
#YV
message ( STATUS "" )
message ( STATUS " GUI: " )
if ( HAVE_QT )
message ( STATUS " QT 4.x: ${HAVE_QT}" )
message ( STATUS " QT OpenGL support: ${HAVE_QT_OPENGL}" )
else ( )
if ( WIN32 )
message ( STATUS " Win32 UI: YES" )
else ( )
if ( APPLE )
if ( WITH_CARBON )
message ( STATUS " Carbon: YES" )
else ( )
message ( STATUS " Cocoa: YES" )
endif ( )
else ( )
message ( STATUS " GTK+ 2.x: ${HAVE_GTK}" )
message ( STATUS " GThread: ${HAVE_GTHREAD}" )
endif ( )
endif ( )
endif ( )
message ( STATUS "" )
message ( STATUS " Media I/O: " )
if ( ZLIB_FOUND )
message ( STATUS " ZLib: ${ZLIB_FOUND}" )
else ( )
message ( STATUS " ZLib: build" )
endif ( )
if ( NOT WITH_JPEG OR JPEG_FOUND )
message ( STATUS " JPEG: ${JPEG_FOUND}" )
else ( )
message ( STATUS " JPEG: build" )
endif ( )
if ( NOT WITH_PNG OR PNG_FOUND )
message ( STATUS " PNG: ${PNG_FOUND}" )
else ( )
message ( STATUS " PNG: build" )
endif ( )
if ( NOT WITH_TIFF OR TIFF_FOUND )
message ( STATUS " TIFF: ${TIFF_FOUND}" )
else ( )
message ( STATUS " TIFF: build" )
endif ( )
if ( NOT WITH_JASPER OR JASPER_FOUND )
message ( STATUS " JPEG 2000: ${JASPER_FOUND}" )
else ( )
message ( STATUS " JPEG 2000: build" )
endif ( )
if ( WITH_OPENEXR AND OPENEXR_FOUND )
message ( STATUS " OpenEXR: YES" )
else ( )
message ( STATUS " OpenEXR: NO" )
endif ( )
if ( NOT HAVE_OPENNI OR HAVE_OPENNI_PRIME_SENSOR_MODULE )
message ( STATUS " OpenNI: ${HAVE_OPENNI}" )
else ( )
message ( STATUS " OpenNI: ${HAVE_OPENNI} (WARNING: PrimeSensor Modules for OpenNI are not installed (not found in OPENNI_PRIME_SENSOR_MODULE_BIN_DIR).)" )
endif ( )
if ( UNIX AND NOT APPLE )
message ( STATUS "" )
message ( STATUS " Video I/O: " )
message ( STATUS " DC1394 1.x: ${HAVE_DC1394}" )
message ( STATUS " DC1394 2.x: ${HAVE_DC1394_2}" )
message ( STATUS " FFMPEG: ${HAVE_FFMPEG}" )
message ( STATUS " codec: ${HAVE_FFMPEG_CODEC}" )
message ( STATUS " format: ${HAVE_FFMPEG_FORMAT}" )
message ( STATUS " util: ${HAVE_FFMPEG_UTIL}" )
message ( STATUS " swscale: ${HAVE_FFMPEG_SWSCALE}" )
message ( STATUS " gentoo-style: ${HAVE_GENTOO_FFMPEG}" )
message ( STATUS " GStreamer: ${HAVE_GSTREAMER}" )
message ( STATUS " UniCap: ${HAVE_UNICAP}" )
message ( STATUS " PvAPI: ${HAVE_PVAPI}" )
if ( HAVE_LIBV4L )
message ( STATUS " V4L/V4L2: Using libv4l" )
else ( )
message ( STATUS " V4L/V4L2: ${HAVE_CAMV4L}/${HAVE_CAMV4L2}" )
endif ( )
message ( STATUS " Xine: ${HAVE_XINE}" )
if ( ANDROID )
if ( ARMEABI_V7A )
if ( BUILD_ANDROID_CAMERA_WRAPPER )
message ( STATUS " AndroidNativeCamera: build for Android ${ANDROID_VERSION}" )
else ( )
message ( STATUS " AndroidNativeCamera: use prebuilt libraries" )
endif ( BUILD_ANDROID_CAMERA_WRAPPER )
else ( ARMEABI_V7A )
message ( STATUS " AndroidNativeCamera: NO" )
endif ( ARMEABI_V7A )
endif ( ANDROID )
endif ( UNIX AND NOT APPLE )
if ( APPLE )
message ( STATUS "" )
if ( WITH_QUICKTIME )
message ( STATUS " Video I/O: QuickTime" )
else ( )
message ( STATUS " Video I/O: QTKit" )
endif ( )
endif ( APPLE )
if ( WIN32 AND HAVE_VIDEOINPUT )
message ( STATUS "" )
message ( STATUS " Video I/O: DirectShow" )
endif ( )
message ( STATUS "" )
message ( STATUS " Interfaces: " )
message ( STATUS " Python: ${BUILD_NEW_PYTHON_SUPPORT}" )
message ( STATUS " Python interpreter: ${PYTHON_EXECUTABLE}" )
if ( PYTHON_USE_NUMPY )
message ( STATUS " Python numpy: YES" )
else ( )
message ( STATUS " Python numpy: NO (Python interface will not cover OpenCV 2.x API)" )
endif ( )
message ( STATUS " Java: ${BUILD_JAVA_SUPPORT}" )
if ( WITH_IPP AND IPP_FOUND )
message ( STATUS " Use IPP: ${IPP_LATEST_VERSION_STR} [${IPP_LATEST_VERSION_MAJOR}.${IPP_LATEST_VERSION_MINOR}.${IPP_LATEST_VERSION_BUILD}]" )
message ( STATUS " at: ${IPP_ROOT_DIR}" )
elseif ( WITH_IPP AND NOT IPP_FOUND )
message ( STATUS " Use IPP: IPP not found" )
else ( )
message ( STATUS " Use IPP: NO" )
endif ( )
if ( HAVE_TBB )
message ( STATUS " Use TBB: YES" )
else ( )
message ( STATUS " Use TBB: NO" )
if ( HAVE_THREADING_FRAMEWORK )
message ( STATUS " Use ThreadingFramework: YES" )
else ( )
message ( STATUS " Use ThreadingFramework: NO" )
endif ( )
endif ( )
if ( HAVE_CUDA )
message ( STATUS " Use Cuda: YES" )
else ( )
message ( STATUS " Use Cuda: NO" )
endif ( )
if ( HAVE_EIGEN )
message ( STATUS " Use Eigen: YES" )
else ( )
message ( STATUS " Use Eigen: NO" )
endif ( )
message ( STATUS "" )
message ( STATUS " Documentation: " )
if ( BUILD_DOCS AND PDFLATEX_COMPILER AND HAVE_SPHINX )
message ( STATUS " Build Documentation: YES" )
else ( )
message ( STATUS " Build Documentation: NO" )
endif ( )
message ( STATUS "" )
message ( STATUS " Install path: ${CMAKE_INSTALL_PREFIX}" )
message ( STATUS "" )
message ( STATUS " cvconfig.h is in: ${OPENCV_CONFIG_FILE_INCLUDE_DIR}" )
message ( STATUS "-----------------------------------------------------------------" )
message ( STATUS "" )
# warn in the case of in-source build
if ( "${CMAKE_CURRENT_SOURCE_DIR}" STREQUAL "${CMAKE_CURRENT_BINARY_DIR}" )
message ( WARNING "The source directory is the same as binary directory. \" make clean\ " may damage the source tree" )
endif ( )
