endif()
endif()
+if(POLICY CMP0020)
+ cmake_policy(SET CMP0020 OLD)
+endif()
+
if(POLICY CMP0022)
cmake_policy(SET CMP0022 OLD)
endif()
cmake_policy(SET CMP0026 OLD)
endif()
-if (POLICY CMP0042)
- # silence cmake 3.0+ warnings about MACOSX_RPATH
- cmake_policy(SET CMP0042 OLD)
+if(POLICY CMP0042)
+ cmake_policy(SET CMP0042 NEW)
endif()
+include(cmake/OpenCVUtils.cmake)
+
# must go before the project command
-set(CMAKE_CONFIGURATION_TYPES "Debug;Release" CACHE STRING "Configs" FORCE)
+ocv_update(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_USE_RELATIVE_PATHS ON CACHE INTERNAL "" FORCE)
endif()
-include(cmake/OpenCVUtils.cmake)
-
ocv_cmake_eval(DEBUG_PRE ONCE)
ocv_clear_vars(OpenCVModules_TARGETS)
OCV_OPTION(WITH_1394 "Include IEEE1394 support" ON IF (NOT ANDROID AND NOT IOS AND NOT WINRT) )
OCV_OPTION(WITH_AVFOUNDATION "Use AVFoundation for Video I/O" ON IF IOS)
OCV_OPTION(WITH_CARBON "Use Carbon for UI instead of Cocoa" OFF IF APPLE )
+OCV_OPTION(WITH_CAROTENE "Use NVidia carotene acceleration library for ARM platform" ON IF (ARM OR AARCH64) AND NOT IOS AND NOT (CMAKE_VERSION VERSION_LESS "2.8.11"))
OCV_OPTION(WITH_VTK "Include VTK library support (and build opencv_viz module eiher)" ON IF (NOT ANDROID AND NOT IOS AND NOT WINRT AND NOT CMAKE_CROSSCOMPILING) )
OCV_OPTION(WITH_CUDA "Include NVidia Cuda Runtime support" ON IF (NOT IOS AND NOT WINRT) )
OCV_OPTION(WITH_CUFFT "Include NVidia Cuda Fast Fourier Transform (FFT) library support" ON IF (NOT IOS AND NOT WINRT) )
OCV_OPTION(WITH_VA_INTEL "Include Intel VA-API/OpenCL support" OFF IF (UNIX AND NOT ANDROID) )
OCV_OPTION(WITH_GDAL "Include GDAL Support" OFF IF (NOT ANDROID AND NOT IOS AND NOT WINRT) )
OCV_OPTION(WITH_GPHOTO2 "Include gPhoto2 library support" ON IF (UNIX AND NOT ANDROID) )
+OCV_OPTION(WITH_LAPACK "Include Lapack library support" ON IF (UNIX AND NOT ANDROID) )
# OpenCV build components
# ===================================================
# ----------------------------------------------------------------------------
# Save libs and executables in the same place
-set(EXECUTABLE_OUTPUT_PATH "${CMAKE_BINARY_DIR}/bin" CACHE PATH "Output directory for applications" )
+set(EXECUTABLE_OUTPUT_PATH "${CMAKE_BINARY_DIR}/bin" CACHE PATH "Output directory for applications")
-if (ANDROID)
- if (ANDROID_ABI MATCHES "NEON")
+if(ANDROID)
+ if(ANDROID_ABI MATCHES "NEON")
set(ENABLE_NEON ON)
endif()
- if (ANDROID_ABI MATCHES "VFPV3")
+ if(ANDROID_ABI MATCHES "VFPV3")
set(ENABLE_VFPV3 ON)
endif()
endif()
if(ANDROID OR WIN32)
- set(OPENCV_DOC_INSTALL_PATH doc)
+ ocv_update(OPENCV_DOC_INSTALL_PATH doc)
else()
- set(OPENCV_DOC_INSTALL_PATH share/OpenCV/doc)
+ ocv_update(OPENCV_DOC_INSTALL_PATH share/OpenCV/doc)
endif()
if(WIN32 AND CMAKE_HOST_SYSTEM_NAME MATCHES Windows)
if(DEFINED OpenCV_RUNTIME AND DEFINED OpenCV_ARCH)
- set(OpenCV_INSTALL_BINARIES_PREFIX "${OpenCV_ARCH}/${OpenCV_RUNTIME}/")
+ ocv_update(OpenCV_INSTALL_BINARIES_PREFIX "${OpenCV_ARCH}/${OpenCV_RUNTIME}/")
else()
message(STATUS "Can't detect runtime and/or arch")
- set(OpenCV_INSTALL_BINARIES_PREFIX "")
+ ocv_update(OpenCV_INSTALL_BINARIES_PREFIX "")
endif()
elseif(ANDROID)
- set(OpenCV_INSTALL_BINARIES_PREFIX "sdk/native/")
+ ocv_update(OpenCV_INSTALL_BINARIES_PREFIX "sdk/native/")
else()
- set(OpenCV_INSTALL_BINARIES_PREFIX "")
+ ocv_update(OpenCV_INSTALL_BINARIES_PREFIX "")
endif()
if(ANDROID)
- set(OPENCV_SAMPLES_BIN_INSTALL_PATH "${OpenCV_INSTALL_BINARIES_PREFIX}samples/${ANDROID_NDK_ABI_NAME}")
+ ocv_update(OPENCV_SAMPLES_BIN_INSTALL_PATH "${OpenCV_INSTALL_BINARIES_PREFIX}samples/${ANDROID_NDK_ABI_NAME}")
else()
- set(OPENCV_SAMPLES_BIN_INSTALL_PATH "${OpenCV_INSTALL_BINARIES_PREFIX}samples")
+ ocv_update(OPENCV_SAMPLES_BIN_INSTALL_PATH "${OpenCV_INSTALL_BINARIES_PREFIX}samples")
endif()
if(ANDROID)
- set(OPENCV_BIN_INSTALL_PATH "${OpenCV_INSTALL_BINARIES_PREFIX}bin/${ANDROID_NDK_ABI_NAME}")
+ ocv_update(OPENCV_BIN_INSTALL_PATH "${OpenCV_INSTALL_BINARIES_PREFIX}bin/${ANDROID_NDK_ABI_NAME}")
else()
- set(OPENCV_BIN_INSTALL_PATH "${OpenCV_INSTALL_BINARIES_PREFIX}bin")
+ ocv_update(OPENCV_BIN_INSTALL_PATH "${OpenCV_INSTALL_BINARIES_PREFIX}bin")
endif()
if(NOT OPENCV_TEST_INSTALL_PATH)
- set(OPENCV_TEST_INSTALL_PATH "${OPENCV_BIN_INSTALL_PATH}")
+ ocv_update(OPENCV_TEST_INSTALL_PATH "${OPENCV_BIN_INSTALL_PATH}")
endif()
if (OPENCV_TEST_DATA_PATH)
if(OPENCV_TEST_DATA_PATH AND NOT OPENCV_TEST_DATA_INSTALL_PATH)
if(ANDROID)
- set(OPENCV_TEST_DATA_INSTALL_PATH "sdk/etc/testdata")
+ ocv_update(OPENCV_TEST_DATA_INSTALL_PATH "sdk/etc/testdata")
elseif(WIN32)
- set(OPENCV_TEST_DATA_INSTALL_PATH "testdata")
+ ocv_update(OPENCV_TEST_DATA_INSTALL_PATH "testdata")
else()
- set(OPENCV_TEST_DATA_INSTALL_PATH "share/OpenCV/testdata")
+ ocv_update(OPENCV_TEST_DATA_INSTALL_PATH "share/OpenCV/testdata")
endif()
endif()
if(ANDROID)
- set(LIBRARY_OUTPUT_PATH "${OpenCV_BINARY_DIR}/lib/${ANDROID_NDK_ABI_NAME}")
- set(3P_LIBRARY_OUTPUT_PATH "${OpenCV_BINARY_DIR}/3rdparty/lib/${ANDROID_NDK_ABI_NAME}")
- set(OPENCV_LIB_INSTALL_PATH sdk/native/libs/${ANDROID_NDK_ABI_NAME})
- set(OPENCV_3P_LIB_INSTALL_PATH sdk/native/3rdparty/libs/${ANDROID_NDK_ABI_NAME})
- set(OPENCV_CONFIG_INSTALL_PATH sdk/native/jni)
- set(OPENCV_INCLUDE_INSTALL_PATH sdk/native/jni/include)
- set(OPENCV_SAMPLES_SRC_INSTALL_PATH samples/native)
- set(OPENCV_OTHER_INSTALL_PATH sdk/etc)
+ set(LIBRARY_OUTPUT_PATH "${OpenCV_BINARY_DIR}/lib/${ANDROID_NDK_ABI_NAME}")
+ ocv_update(3P_LIBRARY_OUTPUT_PATH "${OpenCV_BINARY_DIR}/3rdparty/lib/${ANDROID_NDK_ABI_NAME}")
+ ocv_update(OPENCV_LIB_INSTALL_PATH sdk/native/libs/${ANDROID_NDK_ABI_NAME})
+ ocv_update(OPENCV_3P_LIB_INSTALL_PATH sdk/native/3rdparty/libs/${ANDROID_NDK_ABI_NAME})
+ ocv_update(OPENCV_CONFIG_INSTALL_PATH sdk/native/jni)
+ ocv_update(OPENCV_INCLUDE_INSTALL_PATH sdk/native/jni/include)
+ ocv_update(OPENCV_SAMPLES_SRC_INSTALL_PATH samples/native)
+ ocv_update(OPENCV_OTHER_INSTALL_PATH sdk/etc)
else()
- set(LIBRARY_OUTPUT_PATH "${OpenCV_BINARY_DIR}/lib")
- set(3P_LIBRARY_OUTPUT_PATH "${OpenCV_BINARY_DIR}/3rdparty/lib${LIB_SUFFIX}")
+ set(LIBRARY_OUTPUT_PATH "${OpenCV_BINARY_DIR}/lib")
+ ocv_update(3P_LIBRARY_OUTPUT_PATH "${OpenCV_BINARY_DIR}/3rdparty/lib${LIB_SUFFIX}")
if(WIN32 AND CMAKE_HOST_SYSTEM_NAME MATCHES Windows)
if(OpenCV_STATIC)
- set(OPENCV_LIB_INSTALL_PATH "${OpenCV_INSTALL_BINARIES_PREFIX}staticlib${LIB_SUFFIX}")
+ ocv_update(OPENCV_LIB_INSTALL_PATH "${OpenCV_INSTALL_BINARIES_PREFIX}staticlib${LIB_SUFFIX}")
else()
- set(OPENCV_LIB_INSTALL_PATH "${OpenCV_INSTALL_BINARIES_PREFIX}lib${LIB_SUFFIX}")
+ ocv_update(OPENCV_LIB_INSTALL_PATH "${OpenCV_INSTALL_BINARIES_PREFIX}lib${LIB_SUFFIX}")
endif()
- set(OPENCV_3P_LIB_INSTALL_PATH "${OpenCV_INSTALL_BINARIES_PREFIX}staticlib${LIB_SUFFIX}")
- set(OPENCV_SAMPLES_SRC_INSTALL_PATH samples/native)
- set(OPENCV_JAR_INSTALL_PATH java)
- set(OPENCV_OTHER_INSTALL_PATH etc)
- else()
- set(OPENCV_LIB_INSTALL_PATH lib${LIB_SUFFIX})
- set(OPENCV_3P_LIB_INSTALL_PATH share/OpenCV/3rdparty/${OPENCV_LIB_INSTALL_PATH})
- set(OPENCV_SAMPLES_SRC_INSTALL_PATH share/OpenCV/samples)
- set(OPENCV_JAR_INSTALL_PATH share/OpenCV/java)
- set(OPENCV_OTHER_INSTALL_PATH share/OpenCV)
- endif()
- set(OPENCV_INCLUDE_INSTALL_PATH "include")
-
- math(EXPR SIZEOF_VOID_P_BITS "8 * ${CMAKE_SIZEOF_VOID_P}")
- if(LIB_SUFFIX AND NOT SIZEOF_VOID_P_BITS EQUAL LIB_SUFFIX)
- set(OPENCV_CONFIG_INSTALL_PATH lib${LIB_SUFFIX}/cmake/opencv)
+ ocv_update(OPENCV_3P_LIB_INSTALL_PATH "${OpenCV_INSTALL_BINARIES_PREFIX}staticlib${LIB_SUFFIX}")
+ ocv_update(OPENCV_SAMPLES_SRC_INSTALL_PATH samples/native)
+ ocv_update(OPENCV_JAR_INSTALL_PATH java)
+ ocv_update(OPENCV_OTHER_INSTALL_PATH etc)
+ ocv_update(OPENCV_CONFIG_INSTALL_PATH ".")
else()
- set(OPENCV_CONFIG_INSTALL_PATH share/OpenCV)
+ ocv_update(OPENCV_LIB_INSTALL_PATH lib${LIB_SUFFIX})
+ ocv_update(OPENCV_3P_LIB_INSTALL_PATH share/OpenCV/3rdparty/${OPENCV_LIB_INSTALL_PATH})
+ ocv_update(OPENCV_SAMPLES_SRC_INSTALL_PATH share/OpenCV/samples)
+ ocv_update(OPENCV_JAR_INSTALL_PATH share/OpenCV/java)
+ ocv_update(OPENCV_OTHER_INSTALL_PATH share/OpenCV)
+
+ if(NOT DEFINED OPENCV_CONFIG_INSTALL_PATH)
+ math(EXPR SIZEOF_VOID_P_BITS "8 * ${CMAKE_SIZEOF_VOID_P}")
+ if(LIB_SUFFIX AND NOT SIZEOF_VOID_P_BITS EQUAL LIB_SUFFIX)
+ ocv_update(OPENCV_CONFIG_INSTALL_PATH lib${LIB_SUFFIX}/cmake/opencv)
+ else()
+ ocv_update(OPENCV_CONFIG_INSTALL_PATH share/OpenCV)
+ endif()
+ endif()
endif()
+ ocv_update(OPENCV_INCLUDE_INSTALL_PATH "include")
endif()
-set(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/${OPENCV_LIB_INSTALL_PATH}")
+ocv_update(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/${OPENCV_LIB_INSTALL_PATH}")
set(CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE)
if(INSTALL_TO_MANGLED_PATHS)
set(OPENCV_INCLUDE_INSTALL_PATH ${OPENCV_INCLUDE_INSTALL_PATH}/opencv-${OPENCV_VERSION})
- string(REPLACE "OpenCV" "OpenCV-${OPENCV_VERSION}" OPENCV_3P_LIB_INSTALL_PATH "${OPENCV_3P_LIB_INSTALL_PATH}")
- string(REPLACE "OpenCV" "OpenCV-${OPENCV_VERSION}" OPENCV_SAMPLES_SRC_INSTALL_PATH "${OPENCV_SAMPLES_SRC_INSTALL_PATH}")
- string(REPLACE "OpenCV" "OpenCV-${OPENCV_VERSION}" OPENCV_CONFIG_INSTALL_PATH "${OPENCV_CONFIG_INSTALL_PATH}")
- string(REPLACE "OpenCV" "OpenCV-${OPENCV_VERSION}" OPENCV_DOC_INSTALL_PATH "${OPENCV_DOC_INSTALL_PATH}")
- string(REPLACE "OpenCV" "OpenCV-${OPENCV_VERSION}" OPENCV_JAR_INSTALL_PATH "${OPENCV_JAR_INSTALL_PATH}")
- string(REPLACE "OpenCV" "OpenCV-${OPENCV_VERSION}" OPENCV_TEST_DATA_INSTALL_PATH "${OPENCV_TEST_DATA_INSTALL_PATH}")
- string(REPLACE "OpenCV" "OpenCV-${OPENCV_VERSION}" OPENCV_OTHER_INSTALL_PATH "${OPENCV_OTHER_INSTALL_PATH}")
+ foreach(v
+ OPENCV_3P_LIB_INSTALL_PATH
+ OPENCV_SAMPLES_SRC_INSTALL_PATH
+ OPENCV_CONFIG_INSTALL_PATH
+ OPENCV_DOC_INSTALL_PATH
+ OPENCV_JAR_INSTALL_PATH
+ OPENCV_TEST_DATA_INSTALL_PATH
+ OPENCV_OTHER_INSTALL_PATH
+ )
+ string(REPLACE "OpenCV" "OpenCV-${OPENCV_VERSION}" ${v} "${${v}}")
+ string(REPLACE "opencv" "opencv-${OPENCV_VERSION}" ${v} "${${v}}")
+ endforeach()
endif()
# ----------------------------------------------------------------------------
# Path for build/platform -specific headers
# ----------------------------------------------------------------------------
-set(OPENCV_CONFIG_FILE_INCLUDE_DIR "${CMAKE_BINARY_DIR}/" CACHE PATH "Where to create the platform-dependant cvconfig.h")
+ocv_update(OPENCV_CONFIG_FILE_INCLUDE_DIR "${CMAKE_BINARY_DIR}/" CACHE PATH "Where to create the platform-dependant cvconfig.h")
ocv_include_directories(${OPENCV_CONFIG_FILE_INCLUDE_DIR})
# ----------------------------------------------------------------------------
# ----------------------------------------------------------------------------
find_host_package(Git QUIET)
-if(GIT_FOUND)
+if(NOT DEFINED OPENCV_VCSVERSION AND GIT_FOUND)
execute_process(COMMAND "${GIT_EXECUTABLE}" describe --tags --always --dirty --match "[0-9].[0-9].[0-9]*"
WORKING_DIRECTORY "${OpenCV_SOURCE_DIR}"
OUTPUT_VARIABLE OPENCV_VCSVERSION
if(NOT GIT_RESULT EQUAL 0)
set(OPENCV_VCSVERSION "unknown")
endif()
-else()
+elseif(NOT DEFINED OPENCV_VCSVERSION)
# We don't have git:
set(OPENCV_VCSVERSION "unknown")
endif()
include(cmake/OpenCVDetectVTK.cmake)
-# -- Custom HAL replacement --
-set(_includes "")
-# assuming OPENCV_HAL_HEADERS and OPENCV_HAL_LIBS are lists of files:
-# option example: -DOPENCV_HAL_HEADERS="<some-path>/header1.h;<some-path>/header2.h"
-if (OPENCV_HAL_HEADERS AND OPENCV_HAL_LIBS)
- foreach (h ${OPENCV_HAL_HEADERS})
- get_filename_component(h "${h}" ABSOLUTE)
- set(_includes "${_includes}\n#include \"${h}\"")
+
+# ----------------------------------------------------------------------------
+# OpenCV HAL
+# ----------------------------------------------------------------------------
+set(_hal_includes "")
+macro(ocv_hal_register HAL_LIBRARIES_VAR HAL_HEADERS_VAR HAL_INCLUDE_DIRS_VAR)
+ # 1. libraries
+ foreach (l ${${HAL_LIBRARIES_VAR}})
+ if(NOT TARGET ${l})
+ get_filename_component(l "${l}" ABSOLUTE)
+ endif()
+ list(APPEND OPENCV_HAL_LINKER_LIBS ${l})
endforeach()
- foreach (l ${OPENCV_HAL_LIBS})
- get_filename_component(l "${l}" ABSOLUTE)
- set(OPENCV_LINKER_LIBS ${OPENCV_LINKER_LIBS} ${l})
- # TODO: install?
- # ocv_install_target(${l} EXPORT OpenCVModules ARCHIVE DESTINATION ${OPENCV_3P_LIB_INSTALL_PATH} COMPONENT dev)
+ # 2. headers
+ foreach (h ${${HAL_HEADERS_VAR}})
+ set(_hal_includes "${_hal_includes}\n#include \"${h}\"")
endforeach()
-else()
- set(_includes "// using default HAL")
- unset(OPENCV_HAL_HEADERS CACHE)
- unset(OPENCV_HAL_LIBS CACHE)
+ # 3. include paths
+ ocv_include_directories(${${HAL_INCLUDE_DIRS_VAR}})
+endmacro()
+
+if(NOT DEFINED OpenCV_HAL)
+ set(OpenCV_HAL "OpenCV_HAL")
endif()
-set(OPENCV_HAL_HEADERS "${OPENCV_HAL_HEADERS}" CACHE STRING "Headers with custom HAL implementation")
-set(OPENCV_HAL_LIBS "${OPENCV_HAL_LIBS}" CACHE STRING "Libraries with custom HAL implementation")
+
+if(WITH_CAROTENE)
+ ocv_debug_message(STATUS "Enable carotene acceleration")
+ if(NOT ";${OpenCV_HAL};" MATCHES ";carotene;")
+ set(OpenCV_HAL "carotene;${OpenCV_HAL}")
+ endif()
+endif()
+
+foreach(hal ${OpenCV_HAL})
+ if(hal STREQUAL "carotene")
+ add_subdirectory(3rdparty/carotene/hal)
+ ocv_hal_register(CAROTENE_HAL_LIBRARIES CAROTENE_HAL_HEADERS CAROTENE_HAL_INCLUDE_DIRS)
+ list(APPEND OpenCV_USED_HAL "carotene (ver ${CAROTENE_HAL_VERSION})")
+ else()
+ ocv_debug_message(STATUS "OpenCV HAL: ${hal} ...")
+ ocv_clear_vars(OpenCV_HAL_LIBRARIES OpenCV_HAL_HEADERS OpenCV_HAL_INCLUDE_DIRS)
+ find_package(${hal} NO_MODULE QUIET)
+ if(${hal}_FOUND)
+ ocv_hal_register(OpenCV_HAL_LIBRARIES OpenCV_HAL_HEADERS OpenCV_HAL_INCLUDE_DIRS)
+ list(APPEND OpenCV_USED_HAL "${hal} (ver ${${hal}_VERSION})")
+ endif()
+ endif()
+endforeach()
configure_file("${OpenCV_SOURCE_DIR}/cmake/templates/custom_hal.hpp.in" "${CMAKE_BINARY_DIR}/custom_hal.hpp" @ONLY)
-unset(_includes)
+unset(_hal_includes)
+
# ----------------------------------------------------------------------------
# Add CUDA libraries (needed for apps/tools, samples)
set(OPENCV_LINKER_LIBS ${OPENCV_LINKER_LIBS} ${CUDA_cufft_LIBRARY})
endif()
foreach(p ${CUDA_LIBS_PATH})
- set(OPENCV_LINKER_LIBS ${OPENCV_LINKER_LIBS} -L${p})
+ set(OPENCV_LINKER_LIBS ${OPENCV_LINKER_LIBS} ${CMAKE_LIBRARY_PATH_FLAG}${p})
endforeach()
endif()
# ----------------------------------------------------------------------------
# Generate OpenCV.mk for ndk-build (Android build tool)
include(cmake/OpenCVGenAndroidMK.cmake)
-# Generate OpenCVะกonfig.cmake and OpenCVConfig-version.cmake for cmake projects
+# Generate OpenCVConfig.cmake and OpenCVConfig-version.cmake for cmake projects
include(cmake/OpenCVGenConfig.cmake)
# Generate Info.plist for the IOS framework
configure_file("${CMAKE_CURRENT_SOURCE_DIR}/cmake/templates/opencv_run_all_tests_android.sh.in"
"${CMAKE_BINARY_DIR}/unix-install/opencv_run_all_tests.sh" @ONLY)
install(PROGRAMS "${CMAKE_BINARY_DIR}/unix-install/opencv_run_all_tests.sh"
- DESTINATION ${CMAKE_INSTALL_PREFIX} COMPONENT tests)
+ DESTINATION ./ COMPONENT tests)
elseif(WIN32)
configure_file("${CMAKE_CURRENT_SOURCE_DIR}/cmake/templates/opencv_run_all_tests_windows.cmd.in"
"${CMAKE_BINARY_DIR}/win-install/opencv_run_all_tests.cmd" @ONLY)
if(ANDROID OR NOT UNIX)
install(FILES ${OPENCV_LICENSE_FILE}
PERMISSIONS OWNER_READ GROUP_READ WORLD_READ
- DESTINATION ${CMAKE_INSTALL_PREFIX} COMPONENT libs)
+ DESTINATION ./ COMPONENT libs)
if(OPENCV_README_FILE)
install(FILES ${OPENCV_README_FILE}
PERMISSIONS OWNER_READ GROUP_READ WORLD_READ
- DESTINATION ${CMAKE_INSTALL_PREFIX} COMPONENT libs)
+ DESTINATION ./ COMPONENT libs)
endif()
endif()
if(OPENCV_VCSVERSION)
status(" Version control:" ${OPENCV_VCSVERSION})
endif()
+if(OPENCV_EXTRA_MODULES_PATH AND NOT BUILD_INFO_SKIP_EXTRA_MODULES)
+ set(__dump_extra_header OFF)
+ foreach(p ${OPENCV_EXTRA_MODULES_PATH})
+ if(EXISTS ${p})
+ if(NOT __dump_extra_header)
+ set(__dump_extra_header ON)
+ status("")
+ status(" Extra modules:")
+ else()
+ status("")
+ endif()
+ set(EXTRA_MODULES_VCSVERSION "unknown")
+ if(GIT_FOUND)
+ execute_process(COMMAND "${GIT_EXECUTABLE}" describe --tags --always --dirty --match "[0-9].[0-9].[0-9]*"
+ WORKING_DIRECTORY "${p}"
+ OUTPUT_VARIABLE EXTRA_MODULES_VCSVERSION
+ RESULT_VARIABLE GIT_RESULT
+ ERROR_QUIET
+ OUTPUT_STRIP_TRAILING_WHITESPACE
+ )
+ if(NOT GIT_RESULT EQUAL 0)
+ set(EXTRA_MODULES_VCSVERSION "unknown")
+ endif()
+ endif()
+ status(" Location (extra):" ${p})
+ status(" Version control (extra):" ${EXTRA_MODULES_VCSVERSION})
+ endif()
+ endforeach()
+ unset(__dump_extra_header)
+endif()
# ========================== build platform ==========================
status("")
status(" Platform:")
+if(NOT CMAKE_VERSION VERSION_LESS 2.8.11 AND NOT BUILD_INFO_SKIP_TIMESTAMP)
+ string(TIMESTAMP TIMESTAMP "" UTC)
+ if(TIMESTAMP)
+ status(" Timestamp:" ${TIMESTAMP})
+ endif()
+endif()
status(" Host:" ${CMAKE_HOST_SYSTEM_NAME} ${CMAKE_HOST_SYSTEM_VERSION} ${CMAKE_HOST_SYSTEM_PROCESSOR})
if(CMAKE_CROSSCOMPILING)
status(" Target:" ${CMAKE_SYSTEM_NAME} ${CMAKE_SYSTEM_VERSION} ${CMAKE_SYSTEM_PROCESSOR})
status(" Use Intel VA-API/OpenCL:" HAVE_VA_INTEL THEN "YES (MSDK: ${VA_INTEL_MSDK_ROOT} OpenCL: ${VA_INTEL_IOCL_ROOT})" ELSE NO)
endif(DEFINED WITH_VA_INTEL)
+if(DEFINED WITH_LAPACK)
+status(" Use Lapack:" HAVE_LAPACK THEN "YES" ELSE NO)
+endif(DEFINED WITH_LAPACK)
+
status(" Use Eigen:" HAVE_EIGEN THEN "YES (ver ${EIGEN_WORLD_VERSION}.${EIGEN_MAJOR_VERSION}.${EIGEN_MINOR_VERSION})" ELSE NO)
status(" Use Cuda:" HAVE_CUDA THEN "YES (ver ${CUDA_VERSION_STRING})" ELSE NO)
status(" Use OpenCL:" HAVE_OPENCL THEN YES ELSE NO)
-status(" Use custom HAL:" OPENCV_HAL_HEADERS AND OPENCV_HAL_LIBS THEN "YES (${OPENCV_HAL_HEADERS}; ${OPENCV_HAL_LIBS})" ELSE "NO")
+status(" Use custom HAL:" OpenCV_USED_HAL THEN "YES (${OpenCV_USED_HAL})" ELSE "NO")
if(HAVE_CUDA)
status("")
projects / platform / upstream / opencv.git / blobdiff