# ---------------------------------------------------------------------------- # Root CMake file for OpenCV # # From the off-tree build directory, invoke: # $ cmake # # # - OCT-2008: Initial version # # ---------------------------------------------------------------------------- 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_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/lib") set(CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE) set(CMAKE_CONFIGURATION_TYPES "Debug;Release" CACHE STRING "Configs" FORCE) 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 (WIN32) if(${CMAKE_GENERATOR} MATCHES "(MinGW)|(MSYS)") set(CMAKE_CXX_FLAGS_RELEASE "-O2 -DNDEBUG" CACHE STRING "") endif() endif() if(CMAKE_VERBOSE) set(CMAKE_VERBOSE_MAKEFILE 1) endif() project(OpenCV) cmake_minimum_required(VERSION 2.4) if(MSVC) set(CMAKE_USE_RELATIVE_PATHS ON CACHE INTERNAL "" FORCE) endif() # in case of cross compilation this macro will search packages # for host system instead of packages for target system 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() # -------------------------------------------------------------- # 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() # ---------------------------------------------------------------------------- # Current version number: # ---------------------------------------------------------------------------- set(OPENCV_VERSION "2.3.0") string(REGEX MATCHALL "[0-9]" OPENCV_VERSION_PARTS "${OPENCV_VERSION}") list(GET OPENCV_VERSION_PARTS 0 OPENCV_VERSION_MAJOR) list(GET OPENCV_VERSION_PARTS 1 OPENCV_VERSION_MINOR) list(GET OPENCV_VERSION_PARTS 2 OPENCV_VERSION_PATCH) set(OPENCV_SOVERSION "${OPENCV_VERSION_MAJOR}.${OPENCV_VERSION_MINOR}") if(WIN32) # Postfix of DLLs: set(OPENCV_DLLVERSION "${OPENCV_VERSION_MAJOR}${OPENCV_VERSION_MINOR}${OPENCV_VERSION_PATCH}") set(OPENCV_DEBUG_POSTFIX d) else() # Postfix of so's: #set(OPENCV_DLLVERSION "${OPENCV_VERSION_MAJOR}${OPENCV_VERSION_MINOR}${OPENCV_VERSION_PATCH}") set(OPENCV_DLLVERSION "") set(OPENCV_DEBUG_POSTFIX) 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)") # ---------------------------------------------------------------------------- # 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 CMAKE_C_FLAGS CMAKE_C_FLAGS_DEBUG CMAKE_C_FLAGS_RELEASE CMAKE_C_FLAGS_MINSIZEREL CMAKE_C_FLAGS_RELWITHDEBINFO CMAKE_CXX_FLAGS CMAKE_CXX_FLAGS_DEBUG CMAKE_CXX_FLAGS_RELEASE CMAKE_CXX_FLAGS_MINSIZEREL CMAKE_CXX_FLAGS_RELWITHDEBINFO) if(${flag_var} MATCHES "/MD") string(REGEX REPLACE "/MD" "/MT" ${flag_var} "${${flag_var}}") endif(${flag_var} MATCHES "/MD") if(${flag_var} MATCHES "/MDd") string(REGEX REPLACE "/MDd" "/MTd" ${flag_var} "${${flag_var}}") endif(${flag_var} MATCHES "/MDd") 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 CMAKE_C_FLAGS CMAKE_C_FLAGS_DEBUG CMAKE_C_FLAGS_RELEASE CMAKE_C_FLAGS_MINSIZEREL CMAKE_C_FLAGS_RELWITHDEBINFO CMAKE_CXX_FLAGS CMAKE_CXX_FLAGS_DEBUG CMAKE_CXX_FLAGS_RELEASE CMAKE_CXX_FLAGS_MINSIZEREL CMAKE_CXX_FLAGS_RELWITHDEBINFO) if(${flag_var} MATCHES "/MT") string(REGEX REPLACE "/MT" "/MD" ${flag_var} "${${flag_var}}") endif(${flag_var} MATCHES "/MT") if(${flag_var} MATCHES "/MTd") string(REGEX REPLACE "/MTd" "/MDd" ${flag_var} "${${flag_var}}") endif(${flag_var} MATCHES "/MTd") 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 "") else() set(OPENCV_SVNVERSION " svn:${SVNVERSION_RESULT}") endif() message(STATUS "SVNVERSION: ${OPENCV_SVNVERSION}") 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 OUTPUT_VARIABLE CMAKE_OPENCV_GCC_VERSION_FULL OUTPUT_STRIP_TRAILING_WHITESPACE) execute_process(COMMAND ${CMAKE_CXX_COMPILER} -v ERROR_VARIABLE CMAKE_OPENCV_GCC_INFO_FULL OUTPUT_STRIP_TRAILING_WHITESPACE) # 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 OUTPUT_VARIABLE CMAKE_OPENCV_GCC_TARGET_MACHINE OUTPUT_STRIP_TRAILING_WHITESPACE) 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(MSVC) # set(DEFAULT_ENABLE_OPENMP ON) #else() # set(DEFAULT_ENABLE_OPENMP OFF) #endif() #set(ENABLE_OPENMP ${DEFAULT_ENABLE_OPENMP} CACHE BOOL "") 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" PATHS "/usr/local/include" "/usr/include" DOC "The path to PvAPI header") 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(NOT PYTHONLIBS_FOUND AND PYTHON_INCLUDE_PATH) execute_process(COMMAND ${PYTHON_EXECUTABLE} --version ERROR_VARIABLE PYTHON_VERSION_FULL OUTPUT_STRIP_TRAILING_WHITESPACE) 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) 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]" RESULT_VARIABLE PYTHON_NUMPY_PROCESS OUTPUT_VARIABLE PYTHON_NUMPY_INCLUDE_DIRS OUTPUT_STRIP_TRAILING_WHITESPACE) 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__" RESULT_VARIABLE SPHINX_PROCESS OUTPUT_VARIABLE SPHINX_VERSION OUTPUT_STRIP_TRAILING_WHITESPACE) 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() #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" PATHS "/usr/local/include/eigen2" "/opt/include/eigen2" "/usr/include/eigen2" "/usr/local/include/eigen3" "/opt/include/eigen3" "/usr/include/eigen3" DOC "The path to Eigen2/Eigen3 headers") 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 "Path to Android source tree. Set this variable to path to your Android sources to compile libnative_camera_rx.x.x.so for your Android") 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() ################### DOXYGEN ############### #find_package(Doxygen) # #if(DOXYGEN_FOUND) # set(BUILD_DOXYGEN_DOCS ON CACHE BOOL "Generate HTML docs using Doxygen") #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("." "${OPENCV_CONFIG_FILE_INCLUDE_DIR}" "${CMAKE_CURRENT_SOURCE_DIR}/include" "${CMAKE_CURRENT_SOURCE_DIR}/include/opencv" ) # ---------------------------------------------------------------------------- # 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") 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") #if(ENABLE_OPENMP) # set(EXTRA_C_FLAGS_RELEASE "${EXTRA_C_FLAGS_RELEASE} /openmp") #endif() # 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) if(NOT ANDROID) set(EXTRA_C_FLAGS "${EXTRA_C_FLAGS} -pthread") endif() endif() if(OPENCV_WARNINGS_ARE_ERRORS) set(EXTRA_C_FLAGS "${EXTRA_C_FLAGS} -Werror") endif() if(X86) if(NOT MINGW64) if(NOT X86_64) if(NOT APPLE) set(EXTRA_C_FLAGS "${EXTRA_C_FLAGS} -march=i686") endif() endif() endif() 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) if(${CMAKE_SIZEOF_VOID_P} EQUAL 4) set(EXTRA_C_FLAGS_RELEASE "${EXTRA_C_FLAGS_RELEASE} -mfpmath=387") endif() endif() endif() # Profiling? if(ENABLE_PROFILING) set(EXTRA_C_FLAGS_RELEASE "${EXTRA_C_FLAGS_RELEASE} -pg -g") else() # Remove unreferenced functions: function level linking if(NOT APPLE) set(EXTRA_C_FLAGS "${EXTRA_C_FLAGS} -ffunction-sections") endif() endif() # Parallel mode #if(ENABLE_OPENMP) # set(EXTRA_C_FLAGS "${EXTRA_C_FLAGS} -D_GLIBCXX_PARALLEL -fopenmp") # set(OPENCV_LINKER_LIBS ${OPENCV_LINKER_LIBS} gomp) #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) if(CMAKE_COMPILER_IS_GNUCXX) set(OPENCV_LINKER_LIBS ${OPENCV_LINKER_LIBS} stdc++) set(OPENCV_EXTRA_C_FLAGS "-fPIC ${OPENCV_EXTRA_C_FLAGS}") endif() 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) 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") if("${CMAKE_BUILD_TYPE}" STREQUAL "") set(CMAKE_BUILD_TYPE Release) endif() 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}") # ---------------------------------------------------------------------------- # PROCESS 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) set(OPENCV_DOC_INSTALL_PATH doc) elseif(WIN32) set(OPENCV_DOC_INSTALL_PATH 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() # -------------------------------------------------------------------------------------------- # 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) # -------------------------------------------------------------------------------------------- # Part 2/3: ${BIN_DIR}/unix-install/OpenCVConfig.cmake -> For use *with* "make install" # ------------------------------------------------------------------------------------------- set(CMAKE_INCLUDE_DIRS_CONFIGCMAKE "\"\${OpenCV_INSTALL_PATH}/include/opencv" "\${OpenCV_INSTALL_PATH}/include\"") 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}\"") endif() exec_program(mkdir ARGS "-p \"${CMAKE_BINARY_DIR}/unix-install/\"" OUTPUT_VARIABLE RET_VAL) configure_file("${CMAKE_CURRENT_SOURCE_DIR}/OpenCVConfig.cmake.in" "${CMAKE_BINARY_DIR}/unix-install/OpenCVConfig.cmake" IMMEDIATE @ONLY) if(UNIX) # For a command "FIND_PACKAGE(FOO)", CMake will look at the directory /usr/share|lib/FOO/FOOConfig.cmake, so: install(FILES ${CMAKE_BINARY_DIR}/unix-install/OpenCVConfig.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\" \"\${OpenCV_CONFIG_PATH}/3rdparty/include\"") set(CMAKE_OPENCV2_INCLUDE_DIRS_CONFIGCMAKE "\${THIS_OPENCV_CONFIG_PATH}") set(CMAKE_LIB_DIRS_CONFIGCMAKE "\"\${OpenCV_CONFIG_PATH}/${OPENCV_LIB_INSTALL_PATH}\" \"\${OpenCV_CONFIG_PATH}/3rdparty/${OPENCV_LIB_INSTALL_PATH}\"") set(CMAKE_3RDPARTY_LIB_DIRS_CONFIGCMAKE "\"\${OpenCV_CONFIG_PATH}/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(ARMEABI_V7A) 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() endif(ANDROID) # ------------------------------------------------------------------------------------------- # Part 1/2: ${BIN_DIR}/OpenCV.mk -> For use *without* "make install" # ------------------------------------------------------------------------------------------- if(ANDROID) set(CMAKE_INCLUDE_DIRS_CONFIGCMAKE "\"\$(RELATIVE_PREFIX)${OPENCV_CONFIG_FILE_INCLUDE_DIR}\" \"\$(RELATIVE_PREFIX)${CMAKE_CURRENT_SOURCE_DIR}/include\" \"\$(RELATIVE_PREFIX)${CMAKE_CURRENT_SOURCE_DIR}/include/opencv\"") set(CMAKE_BASE_INCLUDE_DIRS_CONFIGCMAKE "\"\$(RELATIVE_PREFIX)${CMAKE_CURRENT_SOURCE_DIR}\"") set(CMAKE_LIB_DIRS_CONFIGCMAKE "\$(RELATIVE_PREFIX)${LIBRARY_OUTPUT_PATH}") 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 "\$(OPENCV_THIS_DIR)/../../include/opencv \$(OPENCV_THIS_DIR)/../../include") set(CMAKE_BASE_INCLUDE_DIRS_CONFIGCMAKE "") set(CMAKE_LIB_DIRS_CONFIGCMAKE "\$(OPENCV_THIS_DIR)/../../lib") 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) # -------------------------------------------------------------------------------------------- # 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}/include") set(VERSION ${OPENCV_VERSION}) configure_file("${CMAKE_CURRENT_SOURCE_DIR}/opencv.pc.cmake.in" "${CMAKE_BINARY_DIR}/unix-install/opencv.pc" @ONLY IMMEDIATE) if(UNIX AND NOT ANDROID) install(FILES ${CMAKE_BINARY_DIR}/unix-install/opencv.pc DESTINATION ${OPENCV_LIB_INSTALL_PATH}/pkgconfig) endif() if(ANDROID) install(FILES "${CMAKE_CURRENT_SOURCE_DIR}/android/android.toolchain.cmake" DESTINATION share/OpenCV) endif() # ---------------------------------------------------------------------------- # Uninstall target, for "make uninstall" # ---------------------------------------------------------------------------- CONFIGURE_FILE( "${CMAKE_CURRENT_SOURCE_DIR}/cmake_uninstall.cmake.in" "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake" IMMEDIATE @ONLY) 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( Package.cmake.in ${CMAKE_BINARY_DIR}/.cpack/Package.cmake @ONLY ) 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} DESTINATION ${OPENCV_DOC_INSTALL_PATH} COMPONENT main) else() install(FILES ${root_files} DESTINATION "." COMPONENT main) install(FILES ${root_src_files} DESTINATION "." COMPONENT src) # Add the "win-install/OpenCVConfig.cmake" file to the "main" install component install(FILES "${CMAKE_BINARY_DIR}/win-install/OpenCVConfig.cmake" DESTINATION "." COMPONENT main ) install(FILES "include/CMakeLists.txt" DESTINATION "include/" COMPONENT src ) 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 DESTINATION bin COMPONENT main) install(FILES ${LIBRARY_OUTPUT_PATH}/Debug/opencv_${m}${OPENCV_DLLVERSION}d.lib DESTINATION lib COMPONENT main) 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) if(BUILD_EXAMPLES OR INSTALL_PYTHON_EXAMPLES) add_subdirectory(samples) endif() add_subdirectory(3rdparty) # ---------------------------------------------------------------------------- # 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() endif() #if(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() 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() #if(BUILD_DOXYGEN_DOCS AND DOXYGEN_FOUND) #message(STATUS " Doxygen HTMLs YES") #else() #message(STATUS " Doxygen HTMLs 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 "") #---------------------------------------------------------------------------- # Generate the OpenCVConfig.cmake file for unix # installation in CMAKE_INSTALL_PREFIX #----------------------------------------------------------------------------