cmake_policy(SET CMP0068 NEW) # CMake 3.9+: `RPATH` settings on macOS do not affect `install_name`.
endif()
+if(POLICY CMP0075)
+ cmake_policy(SET CMP0075 NEW) # CMake 3.12+: Include file check macros honor `CMAKE_REQUIRED_LIBRARIES`
+endif()
+
#
# Configure OpenCV CMake hooks
# ----------------------------------------------------------------------------
# Detect compiler and target platform architecture
# ----------------------------------------------------------------------------
-OCV_OPTION(ENABLE_CXX11 "Enable C++11 compilation mode" "${OPENCV_CXX11}")
include(cmake/OpenCVDetectCXXCompiler.cmake)
ocv_cmake_hook(POST_DETECT_COMPILER)
# ===================================================
OCV_OPTION(WITH_1394 "Include IEEE1394 support" ON
VISIBLE_IF NOT ANDROID AND NOT IOS AND NOT WINRT
- VERIFY HAVE_DC1394)
+ VERIFY HAVE_DC1394_2)
OCV_OPTION(WITH_AVFOUNDATION "Use AVFoundation for Video I/O (iOS/Mac)" ON
VISIBLE_IF APPLE
VERIFY HAVE_AVFOUNDATION)
-OCV_OPTION(WITH_CARBON "Use Carbon for UI instead of Cocoa (OBSOLETE)" OFF
- VISIBLE_IF (APPLE OR HAVE_COCOA)
- VERIFY HAVE_CARBON)
+OCV_OPTION(WITH_CAP_IOS "Enable iOS video capture" ON
+ VISIBLE_IF IOS
+ VERIFY HAVE_CAP_IOS)
OCV_OPTION(WITH_CAROTENE "Use NVidia carotene acceleration library for ARM platform" ON
VISIBLE_IF (ARM OR AARCH64) AND NOT IOS AND NOT (CMAKE_VERSION VERSION_LESS "2.8.11"))
OCV_OPTION(WITH_CPUFEATURES "Use cpufeatures Android library" ON
OCV_OPTION(WITH_CUBLAS "Include NVidia Cuda Basic Linear Algebra Subprograms (BLAS) library support" WITH_CUDA
VISIBLE_IF WITH_CUDA
VERIFY HAVE_CUBLAS)
-OCV_OPTION(WITH_NVCUVID "Include NVidia Video Decoding library support" WITH_CUDA
+OCV_OPTION(WITH_CUDNN "Include NVIDIA CUDA Deep Neural Network (cuDNN) library support" WITH_CUDA
+ VISIBLE_IF WITH_CUDA
+ VERIFY HAVE_CUDNN)
+OCV_OPTION(WITH_NVCUVID "Include NVidia Video Decoding library support" OFF # disabled, details: https://github.com/opencv/opencv/issues/14850
VISIBLE_IF WITH_CUDA
VERIFY HAVE_NVCUVID)
OCV_OPTION(WITH_EIGEN "Include Eigen2/Eigen3 support" (NOT CV_DISABLE_OPTIMIZATION AND NOT CMAKE_CROSSCOMPILING)
VISIBLE_IF NOT WINRT
VERIFY HAVE_EIGEN)
-OCV_OPTION(WITH_VFW "Include Video for Windows support (deprecated, consider using MSMF)" OFF
- VISIBLE_IF WIN32
- VERIFY HAVE_VFW)
OCV_OPTION(WITH_FFMPEG "Include FFMPEG support" (NOT ANDROID)
VISIBLE_IF NOT IOS AND NOT WINRT
VERIFY HAVE_FFMPEG)
OCV_OPTION(WITH_GSTREAMER "Include Gstreamer support" ON
VISIBLE_IF NOT ANDROID AND NOT IOS AND NOT WINRT
- VERIFY HAVE_GSTREAMER AND GSTREAMER_BASE_VERSION VERSION_GREATER "0.99")
-OCV_OPTION(WITH_GSTREAMER_0_10 "Enable Gstreamer 0.10 support (instead of 1.x)" OFF
- VISIBLE_IF TRUE
- VERIFY HAVE_GSTREAMER AND GSTREAMER_BASE_VERSION VERSION_LESS "1.0")
+ VERIFY HAVE_GSTREAMER AND GSTREAMER_VERSION VERSION_GREATER "0.99")
OCV_OPTION(WITH_GTK "Include GTK support" ON
VISIBLE_IF UNIX AND NOT APPLE AND NOT ANDROID
VERIFY HAVE_GTK)
OCV_OPTION(WITH_HALIDE "Include Halide support" OFF
VISIBLE_IF TRUE
VERIFY HAVE_HALIDE)
+OCV_OPTION(WITH_VULKAN "Include Vulkan support" OFF
+ VISIBLE_IF TRUE
+ VERIFY HAVE_VULKAN)
OCV_OPTION(WITH_INF_ENGINE "Include Intel Inference Engine support" OFF
VISIBLE_IF TRUE
VERIFY INF_ENGINE_TARGET)
+OCV_OPTION(WITH_NGRAPH "Include nGraph support" WITH_INF_ENGINE
+ VISIBLE_IF TRUE
+ VERIFY TARGET ngraph::ngraph)
OCV_OPTION(WITH_JASPER "Include JPEG2K support" ON
VISIBLE_IF NOT IOS
VERIFY HAVE_JASPER)
OCV_OPTION(WITH_PVAPI "Include Prosilica GigE support" OFF
VISIBLE_IF NOT ANDROID AND NOT IOS AND NOT WINRT
VERIFY HAVE_PVAPI)
-OCV_OPTION(WITH_GIGEAPI "Include Smartek GigE support" OFF
- VISIBLE_IF NOT ANDROID AND NOT IOS AND NOT WINRT
- VERIFY HAVE_GIGE_API)
OCV_OPTION(WITH_ARAVIS "Include Aravis GigE support" OFF
VISIBLE_IF NOT ANDROID AND NOT IOS AND NOT WINRT AND NOT WIN32
VERIFY HAVE_ARAVIS_API)
OCV_OPTION(WITH_WIN32UI "Build with Win32 UI Backend support" ON
VISIBLE_IF WIN32 AND NOT WINRT
VERIFY HAVE_WIN32UI)
-OCV_OPTION(WITH_QUICKTIME "Use QuickTime for Video I/O (OBSOLETE)" OFF
- VISIBLE_IF APPLE
- VERIFY HAVE_QUICKTIME)
-OCV_OPTION(WITH_QTKIT "Use QTKit Video I/O backend" OFF
- VISIBLE_IF APPLE
- VERIFY HAVE_QTKIT)
OCV_OPTION(WITH_TBB "Include Intel TBB support" OFF
VISIBLE_IF NOT IOS AND NOT WINRT
VERIFY HAVE_TBB)
+OCV_OPTION(WITH_HPX "Include Ste||ar Group HPX support" OFF
+ VISIBLE_IF TRUE
+ VERIFY HAVE_HPX)
OCV_OPTION(WITH_OPENMP "Include OpenMP support" OFF
VISIBLE_IF TRUE
VERIFY HAVE_OPENMP)
-OCV_OPTION(WITH_CSTRIPES "Include C= support" OFF
- VISIBLE_IF WIN32 AND NOT WINRT
- VERIFY HAVE_CSTRIPES)
OCV_OPTION(WITH_PTHREADS_PF "Use pthreads-based parallel_for" ON
VISIBLE_IF NOT WIN32 OR MINGW
VERIFY HAVE_PTHREADS_PF)
OCV_OPTION(WITH_TIFF "Include TIFF support" ON
VISIBLE_IF NOT IOS
VERIFY HAVE_TIFF)
-OCV_OPTION(WITH_UNICAP "Include Unicap support (GPL)" OFF
- VISIBLE_IF UNIX AND NOT APPLE AND NOT ANDROID
- VERIFY HAVE_UNICAP)
OCV_OPTION(WITH_V4L "Include Video 4 Linux support" ON
VISIBLE_IF UNIX AND NOT ANDROID AND NOT APPLE
VERIFY HAVE_CAMV4L OR HAVE_CAMV4L2 OR HAVE_VIDEOIO)
-OCV_OPTION(WITH_LIBV4L "Use libv4l for Video 4 Linux support" OFF
- VISIBLE_IF UNIX AND NOT ANDROID AND NOT APPLE
- VERIFY HAVE_LIBV4L)
OCV_OPTION(WITH_DSHOW "Build VideoIO with DirectShow support" ON
VISIBLE_IF WIN32 AND NOT ARM AND NOT WINRT
VERIFY HAVE_DSHOW)
OCV_OPTION(WITH_OPENCL_D3D11_NV "Include NVIDIA OpenCL D3D11 support" WITH_DIRECTX
VISIBLE_IF WIN32 AND NOT WINRT
VERIFY HAVE_OPENCL_D3D11_NV)
-OCV_OPTION(WITH_INTELPERC "Include Intel Perceptual Computing support" OFF
- VISIBLE_IF WIN32 AND NOT WINRT
- VERIFY HAVE_INTELPERC)
+OCV_OPTION(WITH_LIBREALSENSE "Include Intel librealsense support" OFF
+ VISIBLE_IF NOT WITH_INTELPERC
+ VERIFY HAVE_LIBREALSENSE)
OCV_OPTION(WITH_VA "Include VA support" OFF
VISIBLE_IF UNIX AND NOT ANDROID
VERIFY HAVE_VA)
OCV_OPTION(WITH_IMGCODEC_PXM "Include PNM (PBM,PGM,PPM) and PAM formats support" ON
VISIBLE_IF TRUE
VERIFY HAVE_IMGCODEC_PXM)
+OCV_OPTION(WITH_IMGCODEC_PFM "Include PFM formats support" ON
+ VISIBLE_IF TRUE
+ VERIFY HAVE_IMGCODEC_PFM)
OCV_OPTION(WITH_QUIRC "Include library QR-code decoding" ON
VISIBLE_IF TRUE
VERIFY HAVE_QUIRC)
+OCV_OPTION(WITH_ANDROID_MEDIANDK "Use Android Media NDK for Video I/O (Android)" (ANDROID_NATIVE_API_LEVEL GREATER 20)
+ VISIBLE_IF ANDROID
+ VERIFY HAVE_ANDROID_MEDIANDK)
# OpenCV build components
# ===================================================
OCV_OPTION(ENABLE_OMIT_FRAME_POINTER "Enable -fomit-frame-pointer for GCC" ON IF CV_GCC )
OCV_OPTION(ENABLE_POWERPC "Enable PowerPC for GCC" ON IF (CV_GCC AND CMAKE_SYSTEM_PROCESSOR MATCHES powerpc.*) )
OCV_OPTION(ENABLE_FAST_MATH "Enable compiler options for fast math optimizations on FP computations (not recommended)" OFF)
-if(NOT IOS) # Use CPU_BASELINE instead
+if(NOT IOS AND (NOT ANDROID OR OPENCV_ANDROID_USE_LEGACY_FLAGS)) # Use CPU_BASELINE instead
OCV_OPTION(ENABLE_NEON "Enable NEON instructions" (NEON OR ANDROID_ARM_NEON OR AARCH64) IF (CV_GCC OR CV_CLANG) AND (ARM OR AARCH64 OR IOS) )
OCV_OPTION(ENABLE_VFPV3 "Enable VFPv3-D32 instructions" OFF IF (CV_GCC OR CV_CLANG) AND (ARM OR AARCH64 OR IOS) )
endif()
OCV_OPTION(ENABLE_LTO "Enable Link Time Optimization" OFF IF CV_GCC OR MSVC)
OCV_OPTION(ENABLE_THIN_LTO "Enable Thin LTO" OFF IF CV_CLANG)
OCV_OPTION(GENERATE_ABI_DESCRIPTOR "Generate XML file for abi_compliance_checker tool" OFF IF UNIX)
-OCV_OPTION(OPENCV_GENERATE_PKGCONFIG "Generate .pc file for pkg-config build tool (deprecated)" ON IF (UNIX AND NOT MSVC AND NOT IOS AND NOT ANDROID) )
+OCV_OPTION(OPENCV_GENERATE_PKGCONFIG "Generate .pc file for pkg-config build tool (deprecated)" OFF)
OCV_OPTION(CV_ENABLE_INTRINSICS "Use intrinsic-based optimized code" ON )
OCV_OPTION(CV_DISABLE_OPTIMIZATION "Disable explicit optimized code (dispatched code/intrinsics/loop unrolling/etc)" OFF )
OCV_OPTION(CV_TRACE "Enable OpenCV code trace" ON)
OCV_OPTION(OPENCV_GENERATE_SETUPVARS "Generate setup_vars* scripts" ON IF (NOT ANDROID AND NOT APPLE_FRAMEWORK) )
OCV_OPTION(ENABLE_CONFIG_VERIFICATION "Fail build if actual configuration doesn't match requested (WITH_XXX != HAVE_XXX)" OFF)
+OCV_OPTION(OPENCV_ENABLE_MEMALIGN "Enable posix_memalign or memalign usage" ON)
OCV_OPTION(ENABLE_PYLINT "Add target with Pylint checks" (BUILD_DOCS OR BUILD_EXAMPLES) IF (NOT CMAKE_CROSSCOMPILING AND NOT APPLE_FRAMEWORK) )
OCV_OPTION(ENABLE_FLAKE8 "Add target with Python flake8 checker" (BUILD_DOCS OR BUILD_EXAMPLES) IF (NOT CMAKE_CROSSCOMPILING AND NOT APPLE_FRAMEWORK) )
# Build & install layouts
# ----------------------------------------------------------------------------
-# Save libs and executables in the same place
-set(EXECUTABLE_OUTPUT_PATH "${CMAKE_BINARY_DIR}/bin" CACHE PATH "Output directory for applications")
-
-if(ANDROID)
- if(ANDROID_ABI MATCHES "NEON")
- set(ENABLE_NEON ON)
- endif()
- if(ANDROID_ABI MATCHES "VFPV3")
- set(ENABLE_VFPV3 ON)
- endif()
-endif()
-
-if(ANDROID OR WIN32)
- ocv_update(OPENCV_DOC_INSTALL_PATH doc)
-else()
- 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)
- ocv_update(OpenCV_INSTALL_BINARIES_PREFIX "${OpenCV_ARCH}/${OpenCV_RUNTIME}/")
- else()
- message(STATUS "Can't detect runtime and/or arch")
- ocv_update(OpenCV_INSTALL_BINARIES_PREFIX "")
- endif()
-elseif(ANDROID)
- ocv_update(OpenCV_INSTALL_BINARIES_PREFIX "sdk/native/")
-else()
- ocv_update(OpenCV_INSTALL_BINARIES_PREFIX "")
-endif()
-
-if(ANDROID)
- ocv_update(OPENCV_SAMPLES_BIN_INSTALL_PATH "${OpenCV_INSTALL_BINARIES_PREFIX}samples/${ANDROID_NDK_ABI_NAME}")
-else()
- ocv_update(OPENCV_SAMPLES_BIN_INSTALL_PATH "${OpenCV_INSTALL_BINARIES_PREFIX}samples")
-endif()
-
-if(ANDROID)
- ocv_update(OPENCV_BIN_INSTALL_PATH "${OpenCV_INSTALL_BINARIES_PREFIX}bin/${ANDROID_NDK_ABI_NAME}")
-else()
- ocv_update(OPENCV_BIN_INSTALL_PATH "${OpenCV_INSTALL_BINARIES_PREFIX}bin")
-endif()
-
-if(NOT OPENCV_TEST_INSTALL_PATH)
- ocv_update(OPENCV_TEST_INSTALL_PATH "${OPENCV_BIN_INSTALL_PATH}")
-endif()
-
-if (OPENCV_TEST_DATA_PATH)
+if(OPENCV_TEST_DATA_PATH)
get_filename_component(OPENCV_TEST_DATA_PATH ${OPENCV_TEST_DATA_PATH} ABSOLUTE)
endif()
-if(ANDROID)
- ocv_update(OPENCV_TEST_DATA_INSTALL_PATH "sdk/etc/testdata")
-elseif(WIN32)
- ocv_update(OPENCV_TEST_DATA_INSTALL_PATH "testdata")
-else()
- ocv_update(OPENCV_TEST_DATA_INSTALL_PATH "share/OpenCV/testdata")
-endif()
+# Save libs and executables in the same place
+set(EXECUTABLE_OUTPUT_PATH "${CMAKE_BINARY_DIR}/bin" CACHE PATH "Output directory for applications")
if(ANDROID)
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_LIB_ARCHIVE_INSTALL_PATH sdk/native/staticlibs/${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)
- ocv_update(OPENCV_LICENSES_INSTALL_PATH "${OPENCV_OTHER_INSTALL_PATH}/licenses")
else()
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)
- ocv_update(OPENCV_LIB_INSTALL_PATH "${OpenCV_INSTALL_BINARIES_PREFIX}staticlib${LIB_SUFFIX}")
- else()
- ocv_update(OPENCV_LIB_INSTALL_PATH "${OpenCV_INSTALL_BINARIES_PREFIX}lib${LIB_SUFFIX}")
- endif()
- ocv_update(OPENCV_3P_LIB_INSTALL_PATH "${OpenCV_INSTALL_BINARIES_PREFIX}staticlib${LIB_SUFFIX}")
- ocv_update(OPENCV_SAMPLES_SRC_INSTALL_PATH samples)
- ocv_update(OPENCV_JAR_INSTALL_PATH java)
- ocv_update(OPENCV_OTHER_INSTALL_PATH etc)
- ocv_update(OPENCV_CONFIG_INSTALL_PATH ".")
- ocv_update(OPENCV_LICENSES_INSTALL_PATH "${OPENCV_OTHER_INSTALL_PATH}/licenses")
- else()
- include(GNUInstallDirs)
- ocv_update(OPENCV_LIB_INSTALL_PATH ${CMAKE_INSTALL_LIBDIR})
- 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)
- ocv_update(OPENCV_LICENSES_INSTALL_PATH "${CMAKE_INSTALL_DATAROOTDIR}/licenses/opencv3")
-
- 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 ${CMAKE_INSTALL_LIBDIR}/cmake/opencv)
- else()
- ocv_update(OPENCV_CONFIG_INSTALL_PATH share/OpenCV)
- endif()
- endif()
- endif()
- ocv_update(OPENCV_INCLUDE_INSTALL_PATH "include")
- #ocv_update(OPENCV_PYTHON_INSTALL_PATH "python") # no default value, see https://github.com/opencv/opencv/issues/13202
-endif()
-
-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})
- 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()
+ ocv_update(3P_LIBRARY_OUTPUT_PATH "${OpenCV_BINARY_DIR}/3rdparty/lib")
endif()
if(ANDROID)
- ocv_update(OPENCV_JNI_INSTALL_PATH "${OPENCV_LIB_INSTALL_PATH}")
-elseif(INSTALL_CREATE_DISTRIB)
- ocv_update(OPENCV_JNI_INSTALL_PATH "${OPENCV_JAR_INSTALL_PATH}/${OpenCV_ARCH}")
-else()
- ocv_update(OPENCV_JNI_INSTALL_PATH "${OPENCV_JAR_INSTALL_PATH}")
-endif()
-ocv_update(OPENCV_JNI_BIN_INSTALL_PATH "${OPENCV_JNI_INSTALL_PATH}")
-
-if(NOT OPENCV_LIB_ARCHIVE_INSTALL_PATH)
- set(OPENCV_LIB_ARCHIVE_INSTALL_PATH ${OPENCV_LIB_INSTALL_PATH})
+ if(ANDROID_ABI MATCHES "NEON")
+ set(ENABLE_NEON ON)
+ endif()
+ if(ANDROID_ABI MATCHES "VFPV3")
+ set(ENABLE_VFPV3 ON)
+ endif()
endif()
if(WIN32)
set(BUILD_opencv_world ON CACHE INTERNAL "")
endif()
+include(cmake/OpenCVInstallLayout.cmake)
+
# ----------------------------------------------------------------------------
# Path for build/platform -specific headers
# ----------------------------------------------------------------------------
set(HAVE_PTHREAD 1)
endif()
- CHECK_SYMBOL_EXISTS(posix_memalign stdlib.h HAVE_POSIX_MEMALIGN)
- CHECK_INCLUDE_FILE(malloc.h HAVE_MALLOC_H)
- if(HAVE_MALLOC_H)
- CHECK_SYMBOL_EXISTS(memalign malloc.h HAVE_MEMALIGN)
+ if(OPENCV_ENABLE_MEMALIGN)
+ CHECK_SYMBOL_EXISTS(posix_memalign stdlib.h HAVE_POSIX_MEMALIGN)
+ CHECK_INCLUDE_FILE(malloc.h HAVE_MALLOC_H)
+ if(HAVE_MALLOC_H)
+ CHECK_SYMBOL_EXISTS(memalign malloc.h HAVE_MEMALIGN)
+ endif()
+ # TODO:
+ # - _aligned_malloc() on Win32
+ # - std::aligned_alloc() C++17 / C11
endif()
endif()
include(cmake/OpenCVDetectHalide.cmake)
endif()
+# --- VkCom ---
+if(WITH_VULKAN)
+ include(cmake/OpenCVDetectVulkan.cmake)
+endif()
+
# --- Inference Engine ---
if(WITH_INF_ENGINE)
include(cmake/OpenCVDetectInferenceEngine.cmake)
# ----------------------------------------------------------------------------
-# Add CUDA libraries (needed for apps/tools, samples)
-# ----------------------------------------------------------------------------
-if(HAVE_CUDA)
- set(OPENCV_LINKER_LIBS ${OPENCV_LINKER_LIBS} ${CUDA_LIBRARIES} ${CUDA_npp_LIBRARY})
- if(HAVE_CUBLAS)
- set(OPENCV_LINKER_LIBS ${OPENCV_LINKER_LIBS} ${CUDA_cublas_LIBRARY})
- endif()
- if(HAVE_CUFFT)
- set(OPENCV_LINKER_LIBS ${OPENCV_LINKER_LIBS} ${CUDA_cufft_LIBRARY})
- endif()
- foreach(p ${CUDA_LIBS_PATH})
- if(MSVC AND CMAKE_GENERATOR MATCHES "Ninja|JOM")
- set(OPENCV_LINKER_LIBS ${OPENCV_LINKER_LIBS} ${CMAKE_LIBRARY_PATH_FLAG}"${p}")
- else()
- set(OPENCV_LINKER_LIBS ${OPENCV_LINKER_LIBS} ${CMAKE_LIBRARY_PATH_FLAG}${p})
- endif()
- endforeach()
-endif()
-
-
-# ----------------------------------------------------------------------------
# Code trace support
# ----------------------------------------------------------------------------
if(CV_TRACE)
endif()
# examples
-if(BUILD_EXAMPLES OR BUILD_ANDROID_EXAMPLES OR INSTALL_PYTHON_EXAMPLES OR INSTALL_C_EXAMPLES)
+if(BUILD_EXAMPLES OR BUILD_ANDROID_EXAMPLES OR INSTALL_ANDROID_EXAMPLES OR INSTALL_PYTHON_EXAMPLES OR INSTALL_C_EXAMPLES)
add_subdirectory(samples)
endif()
include(cmake/OpenCVGenHeaders.cmake)
# Generate opencv.pc for pkg-config command
-if(NOT OPENCV_SKIP_PKGCONFIG_GENERATION
- AND OPENCV_GENERATE_PKGCONFIG
- AND NOT CMAKE_GENERATOR MATCHES "Xcode")
+if(OPENCV_GENERATE_PKGCONFIG)
include(cmake/OpenCVGenPkgconfig.cmake)
endif()
status("")
status(" C/C++:")
status(" Built as dynamic libs?:" BUILD_SHARED_LIBS THEN YES ELSE NO)
-if(ENABLE_CXX11 OR HAVE_CXX11)
-status(" C++11:" HAVE_CXX11 THEN YES ELSE NO)
-endif()
status(" C++ Compiler:" ${OPENCV_COMPILER_STR})
status(" C++ flags (Release):" ${CMAKE_CXX_FLAGS} ${CMAKE_CXX_FLAGS_RELEASE})
status(" C++ flags (Debug):" ${CMAKE_CXX_FLAGS} ${CMAKE_CXX_FLAGS_DEBUG})
IF BUILD_EXAMPLES THEN "examples"
IF BUILD_opencv_apps THEN "apps"
IF BUILD_ANDROID_SERVICE THEN "android_service"
- IF BUILD_ANDROID_EXAMPLES AND CAN_BUILD_ANDROID_PROJECTS THEN "android_examples"
+ IF (BUILD_ANDROID_EXAMPLES OR INSTALL_ANDROID_EXAMPLES) AND CAN_BUILD_ANDROID_PROJECTS THEN "android_examples"
ELSE "-")
status(" Applications:" "${apps_status}")
ocv_build_features_string(docs_status
status(" Win32 UI:" HAVE_WIN32UI THEN YES ELSE NO)
endif()
-if(APPLE)
- if(WITH_CARBON)
- status(" Carbon:" YES)
- else()
- status(" Cocoa:" YES)
- endif()
+if(HAVE_COCOA) # APPLE
+ status(" Cocoa:" YES)
endif()
if(WITH_GTK OR HAVE_GTK)
endif()
if(WITH_GDCM OR HAVE_GDCM)
- status(" GDCM:" HAVE_GDCM THEN "YES (ver ${GDCM_VERSION})" ELSE "NO")
+ status(" GDCM:" HAVE_GDCM THEN "YES (${GDCM_VERSION})" ELSE "NO")
endif()
if(WITH_IMGCODEC_HDR OR DEFINED HAVE_IMGCODEC_HDR)
status(" PXM:" HAVE_IMGCODEC_PXM THEN "YES" ELSE "NO")
endif()
+if(WITH_IMGCODEC_PFM OR DEFINED HAVE_IMGCODEC_PFM)
+ status(" PFM:" HAVE_IMGCODEC_PFM THEN "YES" ELSE "NO")
+endif()
+
# ========================== VIDEO IO ==========================
status("")
status(" Video I/O:")
-if(WITH_VFW OR HAVE_VFW)
- status(" Video for Windows:" HAVE_VFW THEN YES ELSE NO)
-endif()
-
-if(WITH_1394 OR HAVE_DC1394)
- if (HAVE_DC1394_2)
- status(" DC1394:" "YES (ver ${DC1394_2_VERSION})")
- elseif (HAVE_DC1394)
- status(" DC1394:" "YES (ver ${DC1394_VERSION})")
- else()
- status(" DC1394:" "NO")
- endif()
+if(WITH_1394 OR HAVE_DC1394_2)
+ status(" DC1394:" HAVE_DC1394_2 THEN "YES (${DC1394_2_VERSION})" ELSE NO)
endif()
if(WITH_FFMPEG OR HAVE_FFMPEG)
else()
status(" FFMPEG:" HAVE_FFMPEG THEN YES ELSE NO)
endif()
- status(" avcodec:" FFMPEG_libavcodec_FOUND THEN "YES (ver ${FFMPEG_libavcodec_VERSION})" ELSE NO)
- status(" avformat:" FFMPEG_libavformat_FOUND THEN "YES (ver ${FFMPEG_libavformat_VERSION})" ELSE NO)
- status(" avutil:" FFMPEG_libavutil_FOUND THEN "YES (ver ${FFMPEG_libavutil_VERSION})" ELSE NO)
- status(" swscale:" FFMPEG_libswscale_FOUND THEN "YES (ver ${FFMPEG_libswscale_VERSION})" ELSE NO)
- status(" avresample:" FFMPEG_libavresample_FOUND THEN "YES (ver ${FFMPEG_libavresample_VERSION})" ELSE NO)
+ status(" avcodec:" FFMPEG_libavcodec_VERSION THEN "YES (${FFMPEG_libavcodec_VERSION})" ELSE NO)
+ status(" avformat:" FFMPEG_libavformat_VERSION THEN "YES (${FFMPEG_libavformat_VERSION})" ELSE NO)
+ status(" avutil:" FFMPEG_libavutil_VERSION THEN "YES (${FFMPEG_libavutil_VERSION})" ELSE NO)
+ status(" swscale:" FFMPEG_libswscale_VERSION THEN "YES (${FFMPEG_libswscale_VERSION})" ELSE NO)
+ status(" avresample:" FFMPEG_libavresample_VERSION THEN "YES (${FFMPEG_libavresample_VERSION})" ELSE NO)
endif()
if(WITH_GSTREAMER OR HAVE_GSTREAMER)
- status(" GStreamer:" HAVE_GSTREAMER THEN "YES" ELSE NO)
- if(HAVE_GSTREAMER)
- status(" base:" "YES (ver ${GSTREAMER_BASE_VERSION})")
- status(" video:" "YES (ver ${GSTREAMER_VIDEO_VERSION})")
- status(" app:" "YES (ver ${GSTREAMER_APP_VERSION})")
- status(" riff:" "YES (ver ${GSTREAMER_RIFF_VERSION})")
- status(" pbutils:" "YES (ver ${GSTREAMER_PBUTILS_VERSION})")
- endif(HAVE_GSTREAMER)
-endif()
-
-if(WITH_OPENNI OR HAVE_OPENNI)
- status(" OpenNI:" HAVE_OPENNI THEN "YES (ver ${OPENNI_VERSION_STRING}, build ${OPENNI_VERSION_BUILD})" ELSE NO)
- status(" OpenNI PrimeSensor Modules:" HAVE_OPENNI_PRIME_SENSOR_MODULE THEN "YES (${OPENNI_PRIME_SENSOR_MODULE})" ELSE NO)
+ status(" GStreamer:" HAVE_GSTREAMER THEN "YES (${GSTREAMER_VERSION})" ELSE NO)
endif()
if(WITH_OPENNI2 OR HAVE_OPENNI2)
- status(" OpenNI2:" HAVE_OPENNI2 THEN "YES (ver ${OPENNI2_VERSION_STRING}, build ${OPENNI2_VERSION_BUILD})" ELSE NO)
+ status(" OpenNI2:" HAVE_OPENNI2 THEN "YES (${OPENNI2_VERSION})" ELSE NO)
endif()
if(WITH_PVAPI OR HAVE_PVAPI)
- status(" PvAPI:" HAVE_PVAPI THEN YES ELSE NO)
-endif()
-
-if(WITH_GIGEAPI OR HAVE_GIGE_API)
- status(" GigEVisionSDK:" HAVE_GIGE_API THEN YES ELSE NO)
+ status(" PvAPI:" HAVE_PVAPI THEN YES ELSE NO)
endif()
if(WITH_ARAVIS OR HAVE_ARAVIS_API)
- status(" Aravis SDK:" HAVE_ARAVIS_API THEN "YES (${ARAVIS_LIBRARIES})" ELSE NO)
+ status(" Aravis SDK:" HAVE_ARAVIS_API THEN "YES (${ARAVIS_VERSION})" ELSE NO)
endif()
-if(APPLE)
- status(" AVFoundation:" HAVE_AVFOUNDATION THEN YES ELSE NO)
- if(WITH_QUICKTIME OR HAVE_QUICKTIME)
- status(" QuickTime:" HAVE_QUICKTIME THEN YES ELSE NO)
- endif()
- if(WITH_QTKIT OR HAVE_QTKIT)
- status(" QTKit:" HAVE_QTKIT THEN "YES (deprecated)" ELSE NO)
- endif()
+if(WITH_AVFOUNDATION OR HAVE_AVFOUNDATION)
+ status(" AVFoundation:" HAVE_AVFOUNDATION THEN YES ELSE NO)
endif()
-if(WITH_UNICAP OR HAVE_UNICAP)
- status(" UniCap:" HAVE_UNICAP THEN "YES (ver ${UNICAP_libunicap_VERSION})" ELSE NO)
- status(" UniCap ucil:" HAVE_UNICAP THEN "YES (ver ${UNICAP_libucil_VERSION})" ELSE NO)
+if(HAVE_CAP_IOS)
+ status(" iOS capture:" YES)
endif()
-if(WITH_V4L OR WITH_LIBV4L OR HAVE_LIBV4L OR HAVE_CAMV4L OR HAVE_CAMV4L2 OR HAVE_VIDEOIO)
- status(" libv4l/libv4l2:" HAVE_LIBV4L THEN "${LIBV4L_libv4l1_VERSION} / ${LIBV4L_libv4l2_VERSION}" ELSE "NO")
+if(WITH_V4L OR HAVE_V4L)
ocv_build_features_string(v4l_status
- IF HAVE_CAMV4L THEN "linux/videodev.h"
IF HAVE_CAMV4L2 THEN "linux/videodev2.h"
IF HAVE_VIDEOIO THEN "sys/videoio.h"
ELSE "NO")
- status(" v4l/v4l2:" "${v4l_status}")
+ status(" v4l/v4l2:" HAVE_V4L THEN "YES (${v4l_status})" ELSE NO)
endif()
if(WITH_DSHOW OR HAVE_DSHOW)
- status(" DirectShow:" HAVE_DSHOW THEN YES ELSE NO)
+ status(" DirectShow:" HAVE_DSHOW THEN YES ELSE NO)
endif()
if(WITH_MSMF OR HAVE_MSMF)
- status(" Media Foundation:" HAVE_MSMF THEN YES ELSE NO)
- status(" DXVA:" HAVE_MSMF_DXVA THEN YES ELSE NO)
+ status(" Media Foundation:" HAVE_MSMF THEN YES ELSE NO)
+ status(" DXVA:" HAVE_MSMF_DXVA THEN YES ELSE NO)
endif()
if(WITH_XIMEA OR HAVE_XIMEA)
- status(" XIMEA:" HAVE_XIMEA THEN YES ELSE NO)
+ status(" XIMEA:" HAVE_XIMEA THEN YES ELSE NO)
endif()
if(WITH_XINE OR HAVE_XINE)
status(" Xine:" HAVE_XINE THEN "YES (ver ${XINE_VERSION})" ELSE NO)
endif()
-if(WITH_INTELPERC OR HAVE_INTELPERC)
- status(" Intel PerC:" HAVE_INTELPERC THEN "YES" ELSE NO)
+if(WITH_LIBREALSENSE OR HAVE_LIBREALSENSE)
+ status(" Intel RealSense:" HAVE_LIBREALSENSE THEN "YES (${LIBREALSENSE_VERSION})" ELSE NO)
endif()
if(WITH_MFX OR HAVE_MFX)
# Order is similar to CV_PARALLEL_FRAMEWORK in core/src/parallel.cpp
ocv_build_features_string(parallel_status EXCLUSIVE
IF HAVE_TBB THEN "TBB (ver ${TBB_VERSION_MAJOR}.${TBB_VERSION_MINOR} interface ${TBB_INTERFACE_VERSION})"
- IF HAVE_CSTRIPES THEN "C="
+ IF HAVE_HPX THEN "HPX"
IF HAVE_OPENMP THEN "OpenMP"
IF HAVE_GCD THEN "GCD"
IF WINRT OR HAVE_CONCURRENCY THEN "Concurrency"
if(WITH_INF_ENGINE OR INF_ENGINE_TARGET)
if(INF_ENGINE_TARGET)
+ list(GET INF_ENGINE_TARGET 0 ie_target)
set(__msg "YES (${INF_ENGINE_RELEASE} / ${INF_ENGINE_VERSION})")
- get_target_property(_lib ${INF_ENGINE_TARGET} IMPORTED_LOCATION)
- get_target_property(_lib_imp_rel ${INF_ENGINE_TARGET} IMPORTED_IMPLIB_RELEASE)
- get_target_property(_lib_imp_dbg ${INF_ENGINE_TARGET} IMPORTED_IMPLIB_DEBUG)
- get_target_property(_lib_rel ${INF_ENGINE_TARGET} IMPORTED_LOCATION_RELEASE)
- get_target_property(_lib_dbg ${INF_ENGINE_TARGET} IMPORTED_LOCATION_DEBUG)
+ get_target_property(_lib ${ie_target} IMPORTED_LOCATION)
+ get_target_property(_lib_imp_rel ${ie_target} IMPORTED_IMPLIB_RELEASE)
+ get_target_property(_lib_imp_dbg ${ie_target} IMPORTED_IMPLIB_DEBUG)
+ get_target_property(_lib_rel ${ie_target} IMPORTED_LOCATION_RELEASE)
+ get_target_property(_lib_dbg ${ie_target} IMPORTED_LOCATION_DEBUG)
ocv_build_features_string(_lib
IF _lib THEN "${_lib}"
IF _lib_imp_rel AND _lib_imp_dbg THEN "${_lib_imp_rel} / ${_lib_imp_dbg}"
IF _lib_rel AND _lib_dbg THEN "${_lib_rel} / ${_lib_dbg}"
+ IF _lib_rel THEN "${_lib_rel}"
+ IF _lib_dbg THEN "${_lib_dbg}"
ELSE "unknown"
)
- get_target_property(_inc ${INF_ENGINE_TARGET} INTERFACE_INCLUDE_DIRECTORIES)
+ get_target_property(_inc ${ie_target} INTERFACE_INCLUDE_DIRECTORIES)
status(" Inference Engine:" "${__msg}")
- status(" libs:" "${_lib}")
- status(" includes:" "${_inc}")
+ status(" * libs:" "${_lib}")
+ status(" * includes:" "${_inc}")
else()
status(" Inference Engine:" "NO")
endif()
endif()
+if(WITH_NGRAPH OR HAVE_NGRAPH)
+ if(HAVE_NGRAPH)
+ set(__target ngraph::ngraph)
+ set(__msg "YES (${ngraph_VERSION})")
+ get_target_property(_lib ${__target} IMPORTED_LOCATION)
+ get_target_property(_lib_imp_rel ${__target} IMPORTED_IMPLIB_RELEASE)
+ get_target_property(_lib_imp_dbg ${__target} IMPORTED_IMPLIB_DEBUG)
+ get_target_property(_lib_rel ${__target} IMPORTED_LOCATION_RELEASE)
+ get_target_property(_lib_dbg ${__target} IMPORTED_LOCATION_DEBUG)
+ ocv_build_features_string(_lib
+ IF _lib THEN "${_lib}"
+ IF _lib_imp_rel AND _lib_imp_dbg THEN "${_lib_imp_rel} / ${_lib_imp_dbg}"
+ IF _lib_rel AND _lib_dbg THEN "${_lib_rel} / ${_lib_dbg}"
+ IF _lib_rel THEN "${_lib_rel}"
+ IF _lib_dbg THEN "${_lib_dbg}"
+ ELSE "unknown"
+ )
+ get_target_property(_inc ${__target} INTERFACE_INCLUDE_DIRECTORIES)
+ status(" nGraph:" "${__msg}")
+ status(" * libs:" "${_lib}")
+ status(" * includes:" "${_inc}")
+ else()
+ status(" nGraph:" "NO")
+ endif()
+endif()
if(WITH_EIGEN OR HAVE_EIGEN)
status(" Eigen:" HAVE_EIGEN THEN "YES (ver ${EIGEN_WORLD_VERSION}.${EIGEN_MAJOR_VERSION}.${EIGEN_MINOR_VERSION})" ELSE NO)
status(" NVIDIA GPU arch:" ${OPENCV_CUDA_ARCH_BIN})
status(" NVIDIA PTX archs:" ${OPENCV_CUDA_ARCH_PTX})
endif()
+ endif()
+
+ if(WITH_CUDNN OR HAVE_CUDNN)
+ status("")
+ status(" cuDNN:" HAVE_CUDNN THEN "YES (ver ${CUDNN_VERSION})" ELSE NO)
+endif()
+
+if(WITH_VULKAN OR HAVE_VULKAN)
+ status("")
+ status(" Vulkan:" HAVE_VULKAN THEN "YES" ELSE "NO")
+ if(HAVE_VULKAN)
+ status(" Include path:" VULKAN_INCLUDE_DIRS THEN "${VULKAN_INCLUDE_DIRS}" ELSE "NO")
+ status(" Link libraries:" VULKAN_LIBRARIES THEN "${VULKAN_LIBRARIES}" ELSE "Dynamic load")
+ endif()
endif()
if(WITH_OPENCL OR HAVE_OPENCL)
endif()
# ========================== java ==========================
-if(BUILD_JAVA OR BUILD_opencv_java)
+if(BUILD_JAVA)
status("")
status(" Java:" BUILD_FAT_JAVA_LIB THEN "export all functions" ELSE "")
status(" ant:" ANT_EXECUTABLE THEN "${ANT_EXECUTABLE} (ver ${ANT_VERSION})" ELSE NO)
projects / platform / upstream / opencv.git / blobdiff