foreach(mod ${OPENCV_MODULES_BUILD} ${OPENCV_MODULES_DISABLED_USER} ${OPENCV_MODULES_DISABLED_AUTO} ${OPENCV_MODULES_DISABLED_FORCE})

if(HAVE_${mod})

unset(HAVE_${mod} CACHE)

endif()

unset(OPENCV_MODULE_${mod}_DEPS CACHE)

unset(OPENCV_MODULE_${mod}_DEPS_EXT CACHE)

unset(OPENCV_MODULE_${mod}_REQ_DEPS CACHE)

unset(OPENCV_MODULE_${mod}_OPT_DEPS CACHE)

unset(OPENCV_MODULE_${mod}_PRIVATE_REQ_DEPS CACHE)

unset(OPENCV_MODULE_${mod}_PRIVATE_OPT_DEPS CACHE)

unset(OPENCV_MODULE_${mod}_LINK_DEPS CACHE)

unset(OPENCV_MODULE_${mod}_WRAPPERS CACHE)

unset(OPENCV_DEPENDANT_TARGETS_${mod} CACHE)

endforeach()

set(OPENCV_MODULES_PUBLIC "" CACHE INTERNAL "List of OpenCV modules marked for export")

set(OPENCV_MODULES_BUILD "" CACHE INTERNAL "List of OpenCV modules included into the build")

set(OPENCV_MODULES_DISABLED_USER "" CACHE INTERNAL "List of OpenCV modules explicitly disabled by user")

set(OPENCV_MODULES_DISABLED_AUTO "" CACHE INTERNAL "List of OpenCV modules implicitly disabled due to dependencies")

set(OPENCV_MODULES_DISABLED_FORCE "" CACHE INTERNAL "List of OpenCV modules which can not be build in current configuration")

unset(OPENCV_WORLD_MODULES CACHE)

macro(ocv_add_dependencies full_modname)

ocv_debug_message("ocv_add_dependencies(" ${full_modname} ${ARGN} ")")

#we don't clean the dependencies here to allow this macro several times for every module

foreach(d "REQUIRED" ${ARGN})

if(d STREQUAL "REQUIRED")

set(__depsvar OPENCV_MODULE_${full_modname}_REQ_DEPS)

elseif(d STREQUAL "OPTIONAL")

set(__depsvar OPENCV_MODULE_${full_modname}_OPT_DEPS)

elseif(d STREQUAL "PRIVATE_REQUIRED")

set(__depsvar OPENCV_MODULE_${full_modname}_PRIVATE_REQ_DEPS)

elseif(d STREQUAL "PRIVATE_OPTIONAL")

set(__depsvar OPENCV_MODULE_${full_modname}_PRIVATE_OPT_DEPS)

elseif(d STREQUAL "WRAP")

set(__depsvar OPENCV_MODULE_${full_modname}_WRAPPERS)

else()

list(APPEND ${__depsvar} "${d}")

endif()

endforeach()

unset(__depsvar)

# hack for python

set(__python_idx)

list(FIND OPENCV_MODULE_${full_modname}_WRAPPERS "python" __python_idx)

if (NOT __python_idx EQUAL -1)

list(REMOVE_ITEM OPENCV_MODULE_${full_modname}_WRAPPERS "python")

list(APPEND OPENCV_MODULE_${full_modname}_WRAPPERS "python_bindings_generator" "python2" "python3")

endif()

unset(__python_idx)

ocv_list_unique(OPENCV_MODULE_${full_modname}_REQ_DEPS)

ocv_list_unique(OPENCV_MODULE_${full_modname}_OPT_DEPS)

ocv_list_unique(OPENCV_MODULE_${full_modname}_PRIVATE_REQ_DEPS)

ocv_list_unique(OPENCV_MODULE_${full_modname}_PRIVATE_OPT_DEPS)

ocv_list_unique(OPENCV_MODULE_${full_modname}_WRAPPERS)

set(OPENCV_MODULE_${full_modname}_REQ_DEPS ${OPENCV_MODULE_${full_modname}_REQ_DEPS}

CACHE INTERNAL "Required dependencies of ${full_modname} module")

set(OPENCV_MODULE_${full_modname}_OPT_DEPS ${OPENCV_MODULE_${full_modname}_OPT_DEPS}

CACHE INTERNAL "Optional dependencies of ${full_modname} module")

set(OPENCV_MODULE_${full_modname}_PRIVATE_REQ_DEPS ${OPENCV_MODULE_${full_modname}_PRIVATE_REQ_DEPS}

CACHE INTERNAL "Required private dependencies of ${full_modname} module")

set(OPENCV_MODULE_${full_modname}_PRIVATE_OPT_DEPS ${OPENCV_MODULE_${full_modname}_PRIVATE_OPT_DEPS}

CACHE INTERNAL "Optional private dependencies of ${full_modname} module")

set(OPENCV_MODULE_${full_modname}_WRAPPERS ${OPENCV_MODULE_${full_modname}_WRAPPERS}

CACHE INTERNAL "List of wrappers supporting module ${full_modname}")

endmacro()

macro(ocv_add_module _name)

ocv_debug_message("ocv_add_module(" ${_name} ${ARGN} ")")

string(TOLOWER "${_name}" name)

set(the_module opencv_${name})

# the first pass - collect modules info, the second pass - create targets

if(OPENCV_INITIAL_PASS)

#guard agains redefinition

if(";${OPENCV_MODULES_BUILD};${OPENCV_MODULES_DISABLED_USER};" MATCHES ";${the_module};")

message(FATAL_ERROR "Redefinition of the ${the_module} module.

")

endif()

if(NOT DEFINED the_description)

set(the_description "The ${name} OpenCV module")

endif()

if(NOT DEFINED BUILD_${the_module}_INIT)

set(BUILD_${the_module}_INIT ON)

endif()

# create option to enable/disable this module

option(BUILD_${the_module} "Include ${the_module} module into the OpenCV build" ${BUILD_${the_module}_INIT})

# remember the module details

set(OPENCV_MODULE_${the_module}_DESCRIPTION "${the_description}" CACHE INTERNAL "Brief description of ${the_module} module")

set(OPENCV_MODULE_${the_module}_LOCATION "${CMAKE_CURRENT_SOURCE_DIR}" CACHE INTERNAL "Location of ${the_module} module sources")

set(OPENCV_MODULE_${the_module}_LINK_DEPS "" CACHE INTERNAL "")

# parse list of dependencies

if("${ARGV1}" STREQUAL "INTERNAL" OR "${ARGV1}" STREQUAL "BINDINGS")

set(OPENCV_MODULE_${the_module}_CLASS "${ARGV1}" CACHE INTERNAL "The category of the module")

set(__ocv_argn__ ${ARGN})

list(REMOVE_AT __ocv_argn__ 0)

ocv_add_dependencies(${the_module} ${__ocv_argn__})

unset(__ocv_argn__)

else()

set(OPENCV_MODULE_${the_module}_CLASS "PUBLIC" CACHE INTERNAL "The category of the module")

ocv_add_dependencies(${the_module} ${ARGN})

if(BUILD_${the_module})

set(OPENCV_MODULES_PUBLIC ${OPENCV_MODULES_PUBLIC} "${the_module}" CACHE INTERNAL "List of OpenCV modules marked for export")

endif()

endif()

# add self to the world dependencies

if((NOT DEFINED OPENCV_MODULE_IS_PART_OF_WORLD

AND NOT OPENCV_MODULE_${the_module}_CLASS STREQUAL "BINDINGS"

AND (NOT OPENCV_PROCESSING_EXTRA_MODULES OR NOT OPENCV_WORLD_EXCLUDE_EXTRA_MODULES)

AND (NOT BUILD_SHARED_LIBS OR NOT "x${OPENCV_MODULE_TYPE}" STREQUAL "xSTATIC"))

OR OPENCV_MODULE_IS_PART_OF_WORLD

)

set(OPENCV_MODULE_${the_module}_IS_PART_OF_WORLD ON CACHE INTERNAL "")

ocv_add_dependencies(opencv_world OPTIONAL ${the_module})

else()

set(OPENCV_MODULE_${the_module}_IS_PART_OF_WORLD OFF CACHE INTERNAL "")

endif()

if(NOT DEFINED the_label)

if(OPENCV_PROCESSING_EXTRA_MODULES)

set(the_label "Extra")

else()

set(the_label "Main")

endif()

endif()

set(OPENCV_MODULE_${the_module}_LABEL "${the_label};${the_module}" CACHE INTERNAL "")

if(BUILD_${the_module})

set(OPENCV_MODULES_BUILD ${OPENCV_MODULES_BUILD} "${the_module}" CACHE INTERNAL "List of OpenCV modules included into the build")

else()

set(OPENCV_MODULES_DISABLED_USER ${OPENCV_MODULES_DISABLED_USER} "${the_module}" CACHE INTERNAL "List of OpenCV modules explicitly disabled by user")

endif()

# add reverse wrapper dependencies

foreach (wrapper ${OPENCV_MODULE_${the_module}_WRAPPERS})

ocv_add_dependencies(opencv_${wrapper} OPTIONAL ${the_module})

endforeach()

# stop processing of current file

return()

else()

set(OPENCV_MODULE_${the_module}_BINARY_DIR "${CMAKE_CURRENT_BINARY_DIR}" CACHE INTERNAL "")

if(NOT BUILD_${the_module})

return() # extra protection from redefinition

endif()

if(NOT OPENCV_MODULE_${the_module}_IS_PART_OF_WORLD OR NOT ${BUILD_opencv_world})

if (NOT ${the_module} STREQUAL opencv_world)

project(${the_module})

endif()

add_definitions(

-D_USE_MATH_DEFINES # M_PI constant in MSVS

-D__STDC_CONSTANT_MACROS -D__STDC_LIMIT_MACROS -D__STDC_FORMAT_MACROS # to use C libraries from C++ code (ffmpeg)

)

endif()

endif()

endmacro()

macro(ocv_module_disable_ module)

set(__modname ${module})

if(NOT __modname MATCHES "^opencv_")

set(__modname opencv_${module})

endif()

list(APPEND OPENCV_MODULES_DISABLED_FORCE "${__modname}")

set(HAVE_${__modname} OFF CACHE INTERNAL "Module ${__modname} can not be built in current configuration")

set(OPENCV_MODULE_${__modname}_LOCATION "${CMAKE_CURRENT_SOURCE_DIR}" CACHE INTERNAL "Location of ${__modname} module sources")

set(OPENCV_MODULES_DISABLED_FORCE "${OPENCV_MODULES_DISABLED_FORCE}" CACHE INTERNAL "List of OpenCV modules which can not be build in current configuration")

if(BUILD_${__modname})

# touch variable controlling build of the module to suppress "unused variable" CMake warning

endif()

unset(__modname)

endmacro()

macro(ocv_module_disable module)

ocv_module_disable_(${module})

return() # leave the current folder

endmacro()

macro(ocv_glob_modules)

if(DEFINED OPENCV_INITIAL_PASS)

message(FATAL_ERROR "OpenCV has already loaded its modules. Calling ocv_glob_modules second time is not allowed.")

endif()

set(__directories_observed "")

# collect modules

set(OPENCV_INITIAL_PASS ON)

set(OPENCV_PROCESSING_EXTRA_MODULES 0)

foreach(__path ${ARGN})

if("${__path}" STREQUAL "EXTRA")

set(OPENCV_PROCESSING_EXTRA_MODULES 1)

else()

get_filename_component(__path "${__path}" ABSOLUTE)

list(FIND __directories_observed "${__path}" __pathIdx)

if(__pathIdx GREATER -1)

message(FATAL_ERROR "The directory ${__path} is observed for OpenCV modules second time.")

endif()

list(APPEND __directories_observed "${__path}")

set(__count 0)

file(GLOB __ocvmodules RELATIVE "${__path}" "${__path}/*")

if(__ocvmodules)

list(SORT __ocvmodules)

foreach(mod ${__ocvmodules})

get_filename_component(__modpath "${__path}/${mod}" ABSOLUTE)

if(EXISTS "${__modpath}/CMakeLists.txt")

list(FIND __directories_observed "${__modpath}" __pathIdx)

if(__pathIdx GREATER -1)

message(FATAL_ERROR "The module from ${__modpath} is already loaded.")

endif()

list(APPEND __directories_observed "${__modpath}")

add_subdirectory("${__modpath}" "${CMAKE_CURRENT_BINARY_DIR}/${mod}/.${mod}")

if (DEFINED OPENCV_MODULE_opencv_${mod}_LOCATION)

math(EXPR __count "${__count} + 1")

endif()

endif()

endforeach()

endif()

if (OPENCV_PROCESSING_EXTRA_MODULES AND ${__count} LESS 1)

message(SEND_ERROR "No extra modules found in folder: ${__path}\nPlease provide path to 'opencv_contrib/modules' folder.")

endif()

endif()

endforeach()

ocv_clear_vars(__ocvmodules __directories_observed __path __modpath __pathIdx)

# resolve dependencies

__ocv_resolve_dependencies()

# create modules

set(OPENCV_INITIAL_PASS OFF PARENT_SCOPE)

set(OPENCV_INITIAL_PASS OFF)

if(${BUILD_opencv_world})

foreach(m ${OPENCV_MODULES_BUILD})

set(the_module "${m}")

if("${m}" STREQUAL opencv_world)

add_subdirectory("${OPENCV_MODULE_opencv_world_LOCATION}" "${CMAKE_CURRENT_BINARY_DIR}/world")

elseif(NOT OPENCV_MODULE_${m}_IS_PART_OF_WORLD AND NOT ${m} STREQUAL opencv_world)

message(STATUS "Processing module ${m}...")

if(m MATCHES "^opencv_")

string(REGEX REPLACE "^opencv_" "" __shortname "${m}")

add_subdirectory("${OPENCV_MODULE_${m}_LOCATION}" "${CMAKE_CURRENT_BINARY_DIR}/${__shortname}")

else()

message(WARNING "Check module name: ${m}")

add_subdirectory("${OPENCV_MODULE_${m}_LOCATION}" "${CMAKE_CURRENT_BINARY_DIR}/${m}")

endif()

endif()

endforeach()

else()

foreach(m ${OPENCV_MODULES_BUILD})

set(the_module "${m}")

if(m MATCHES "^opencv_")

string(REGEX REPLACE "^opencv_" "" __shortname "${m}")

add_subdirectory("${OPENCV_MODULE_${m}_LOCATION}" "${CMAKE_CURRENT_BINARY_DIR}/${__shortname}")

else()

message(WARNING "Check module name: ${m}")

add_subdirectory("${OPENCV_MODULE_${m}_LOCATION}" "${CMAKE_CURRENT_BINARY_DIR}/${m}")

endif()

endforeach()

endif()

unset(__shortname)

endmacro()

function(__ocv_module_turn_off the_module)

list(REMOVE_ITEM OPENCV_MODULES_DISABLED_AUTO "${the_module}")

list(APPEND OPENCV_MODULES_DISABLED_AUTO "${the_module}")

list(REMOVE_ITEM OPENCV_MODULES_BUILD "${the_module}")

list(REMOVE_ITEM OPENCV_MODULES_PUBLIC "${the_module}")

set(HAVE_${the_module} OFF CACHE INTERNAL "Module ${the_module} can not be built in current configuration")

set(OPENCV_MODULES_DISABLED_AUTO "${OPENCV_MODULES_DISABLED_AUTO}" CACHE INTERNAL "")

set(OPENCV_MODULES_BUILD "${OPENCV_MODULES_BUILD}" CACHE INTERNAL "")

set(OPENCV_MODULES_PUBLIC "${OPENCV_MODULES_PUBLIC}" CACHE INTERNAL "")

endfunction()

function(__ocv_sort_modules_by_deps __lst)

ocv_list_sort(${__lst})

set(input ${${__lst}})

set(result "")

set(result_extra "")

while(input)

list(LENGTH input length_before)

foreach (m ${input})

# check if module is in the result already

if (NOT ";${result};" MATCHES ";${m};")

# scan through module dependencies...

set(unresolved_deps_found FALSE)

foreach (d ${OPENCV_MODULE_${m}_DEPS})

# ... which are not already in the result and are enabled

if ((NOT ";${result};" MATCHES ";${d};") AND HAVE_${d})

set(unresolved_deps_found TRUE)

break()

endif()

endforeach()

# chek if all dependencies for this module has been resolved

if (NOT unresolved_deps_found)

list(APPEND result ${m})

list(REMOVE_ITEM input ${m})

endif()

endif()

endforeach()

list(LENGTH input length_after)

# check for infinite loop or unresolved dependencies

if (NOT length_after LESS length_before)

if(NOT BUILD_SHARED_LIBS)

if (";${input};" MATCHES ";opencv_world;")

list(REMOVE_ITEM input "opencv_world")

list(APPEND result_extra "opencv_world")

else()

# We can't do here something

list(APPEND result ${input})

break()

endif()

else()

message(FATAL_ERROR WARNING "Unresolved dependencies or loop in dependency graph (${length_after})\n"

"Processed ${__lst}: ${${__lst}}\n"

"Good modules: ${result}\n"

"Bad modules: ${input}"

)

list(APPEND result ${input})

break()

endif()

endif()

endwhile()

set(${__lst} "${result};${result_extra}" PARENT_SCOPE)

endfunction()

function(__ocv_resolve_dependencies)

foreach(m ${OPENCV_MODULES_DISABLED_USER})

set(HAVE_${m} OFF CACHE INTERNAL "Module ${m} will not be built in current configuration")

endforeach()

foreach(m ${OPENCV_MODULES_BUILD})

set(HAVE_${m} ON CACHE INTERNAL "Module ${m} will be built in current configuration")

endforeach()

# Whitelist feature

if(BUILD_LIST)

# Prepare the list

string(REGEX REPLACE "[ ,:]+" ";" whitelist "${BUILD_LIST}" )

if(BUILD_opencv_world)

list(APPEND whitelist world)

endif()

ocv_list_add_prefix(whitelist "opencv_")

ocv_list_sort(whitelist)

ocv_list_unique(whitelist)

message(STATUS "Using whitelist: ${whitelist}")

# Expand the list

foreach(depth RANGE 10)

set(new_whitelist ${whitelist})

foreach(m ${whitelist})

list(APPEND new_whitelist ${OPENCV_MODULE_${m}_REQ_DEPS})

list(APPEND new_whitelist ${OPENCV_MODULE_${m}_PRIVATE_REQ_DEPS})

endforeach()

ocv_list_sort(new_whitelist)

ocv_list_unique(new_whitelist)

if("${whitelist}" STREQUAL "${new_whitelist}")

break()

endif()

set(whitelist "${new_whitelist}")

endforeach()

# Disable modules not in whitelist

foreach(m ${OPENCV_MODULES_BUILD})

list(FIND whitelist ${m} idx)

if(idx EQUAL -1)

message(STATUS "Module ${m} disabled by whitelist")

__ocv_module_turn_off(${m})

endif()

endforeach()

endif()

# disable MODULES with unresolved dependencies

set(has_changes ON)

while(has_changes)

set(has_changes OFF)

foreach(m ${OPENCV_MODULES_BUILD})

set(__deps ${OPENCV_MODULE_${m}_REQ_DEPS} ${OPENCV_MODULE_${m}_PRIVATE_REQ_DEPS})

while(__deps)

ocv_list_pop_front(__deps d)

string(TOLOWER "${d}" upper_d)

if(NOT (HAVE_${d} OR HAVE_${upper_d} OR TARGET ${d} OR EXISTS ${d}))

if(d MATCHES "^opencv_") # TODO Remove this condition in the future and use HAVE_ variables only

message(STATUS "Module ${m} disabled because ${d} dependency can't be resolved!")

__ocv_module_turn_off(${m})

set(has_changes ON)

break()

else()

message(STATUS "Assume that non-module dependency is available: ${d} (for module ${m})")

endif()

endif()

endwhile()

endforeach()

endwhile()

foreach(m ${OPENCV_MODULES_BUILD})

set(deps_${m} ${OPENCV_MODULE_${m}_REQ_DEPS})

foreach(d ${OPENCV_MODULE_${m}_OPT_DEPS})

if(NOT (";${deps_${m}};" MATCHES ";${d};"))

if(HAVE_${d} OR TARGET ${d})

list(APPEND deps_${m} ${d})

endif()

endif()

endforeach()

endforeach()

# propagate dependencies

set(has_changes ON)

while(has_changes)

set(has_changes OFF)

foreach(m2 ${OPENCV_MODULES_BUILD}) # transfer deps of m2 to m

foreach(m ${OPENCV_MODULES_BUILD})

if((NOT m STREQUAL m2) AND ";${deps_${m}};" MATCHES ";${m2};")

foreach(d ${deps_${m2}})

if(NOT (";${deps_${m}};" MATCHES ";${d};"))

list(APPEND deps_${m} ${d})

set(has_changes ON)

endif()

if(BUILD_opencv_world

AND NOT "${m}" STREQUAL "opencv_world"

AND NOT "${m2}" STREQUAL "opencv_world"

AND OPENCV_MODULE_${m2}_IS_PART_OF_WORLD

AND NOT OPENCV_MODULE_${m}_IS_PART_OF_WORLD)

if(NOT (";${deps_${m}};" MATCHES ";opencv_world;"))

list(APPEND deps_${m} opencv_world)

set(has_changes ON)

endif()

endif()

endforeach()

endif()

endforeach()

endforeach()

endwhile()

# process private deps

foreach(m ${OPENCV_MODULES_BUILD})

foreach(d ${OPENCV_MODULE_${m}_PRIVATE_REQ_DEPS})

if(NOT (";${deps_${m}};" MATCHES ";${d};"))

list(APPEND deps_${m} ${d})

endif()

endforeach()

foreach(d ${OPENCV_MODULE_${m}_PRIVATE_OPT_DEPS})

if(NOT (";${deps_${m}};" MATCHES ";${d};"))

if(HAVE_${d} OR TARGET ${d})

list(APPEND deps_${m} ${d})

endif()

endif()

endforeach()

endforeach()

ocv_list_sort(OPENCV_MODULES_BUILD)

foreach(m ${OPENCV_MODULES_BUILD})

set(OPENCV_MODULE_${m}_DEPS ${deps_${m}})

set(OPENCV_MODULE_${m}_DEPS_EXT ${deps_${m}})

ocv_list_filterout(OPENCV_MODULE_${m}_DEPS_EXT "^opencv_[^ ]+$")

if(OPENCV_MODULE_${m}_DEPS_EXT AND OPENCV_MODULE_${m}_DEPS)

list(REMOVE_ITEM OPENCV_MODULE_${m}_DEPS ${OPENCV_MODULE_${m}_DEPS_EXT})

endif()

endforeach()

# reorder dependencies

foreach(m ${OPENCV_MODULES_BUILD})

__ocv_sort_modules_by_deps(OPENCV_MODULE_${m}_DEPS)

set(LINK_DEPS ${OPENCV_MODULE_${m}_DEPS})

# process world

if(BUILD_opencv_world)

if(OPENCV_MODULE_${m}_IS_PART_OF_WORLD)

list(APPEND OPENCV_WORLD_MODULES ${m})

endif()

foreach(m2 ${OPENCV_MODULES_BUILD})

if(OPENCV_MODULE_${m2}_IS_PART_OF_WORLD)

if(";${LINK_DEPS};" MATCHES ";${m2};")

list(REMOVE_ITEM LINK_DEPS ${m2})

if(NOT (";${LINK_DEPS};" MATCHES ";opencv_world;") AND NOT (${m} STREQUAL opencv_world))

list(APPEND LINK_DEPS opencv_world)

endif()

endif()

if(${m} STREQUAL opencv_world)

list(APPEND OPENCV_MODULE_opencv_world_DEPS_EXT ${OPENCV_MODULE_${m2}_DEPS_EXT})

endif()

endif()

endforeach()

endif()

set(OPENCV_MODULE_${m}_DEPS ${OPENCV_MODULE_${m}_DEPS} CACHE INTERNAL "Flattened dependencies of ${m} module")

set(OPENCV_MODULE_${m}_DEPS_EXT ${OPENCV_MODULE_${m}_DEPS_EXT} CACHE INTERNAL "Extra dependencies of ${m} module")

set(OPENCV_MODULE_${m}_DEPS_TO_LINK ${LINK_DEPS} CACHE INTERNAL "Flattened dependencies of ${m} module (for linker)")

endforeach()

__ocv_sort_modules_by_deps(OPENCV_MODULES_BUILD)

set(OPENCV_MODULES_PUBLIC ${OPENCV_MODULES_PUBLIC} CACHE INTERNAL "List of OpenCV modules marked for export")

set(OPENCV_MODULES_BUILD ${OPENCV_MODULES_BUILD} CACHE INTERNAL "List of OpenCV modules included into the build")

set(OPENCV_MODULES_DISABLED_AUTO ${OPENCV_MODULES_DISABLED_AUTO} CACHE INTERNAL "List of OpenCV modules implicitly disabled due to dependencies")

set(OPENCV_WORLD_MODULES ${OPENCV_WORLD_MODULES} CACHE INTERNAL "List of OpenCV modules included into the world")

endfunction()

macro(ocv_include_modules)

foreach(d ${ARGN})

if(d MATCHES "^opencv_" AND HAVE_${d})

if (EXISTS "${OPENCV_MODULE_${d}_LOCATION}/include")

ocv_include_directories("${OPENCV_MODULE_${d}_LOCATION}/include")

endif()

elseif(EXISTS "${d}")

ocv_include_directories("${d}")

endif()

endforeach()

endmacro()

macro(ocv_include_modules_recurse)

ocv_include_modules(${ARGN})

foreach(d ${ARGN})

if(d MATCHES "^opencv_" AND HAVE_${d} AND DEFINED OPENCV_MODULE_${d}_DEPS)

foreach (sub ${OPENCV_MODULE_${d}_DEPS})

ocv_include_modules(${sub})

endforeach()

endif()

endforeach()

endmacro()

macro(ocv_target_include_modules target)

foreach(d ${ARGN})

if(d MATCHES "^opencv_" AND HAVE_${d})

if (EXISTS "${OPENCV_MODULE_${d}_LOCATION}/include")

ocv_target_include_directories(${target} "${OPENCV_MODULE_${d}_LOCATION}/include")

endif()

elseif(EXISTS "${d}")

ocv_target_include_directories(${target} "${d}")

endif()

endforeach()

endmacro()

macro(ocv_target_include_modules_recurse target)

foreach(d ${ARGN})

if(d MATCHES "^opencv_" AND HAVE_${d})

if (EXISTS "${OPENCV_MODULE_${d}_LOCATION}/include")

ocv_target_include_directories(${target} "${OPENCV_MODULE_${d}_LOCATION}/include")

endif()

if(OPENCV_MODULE_${d}_DEPS)

ocv_target_include_modules(${target} ${OPENCV_MODULE_${d}_DEPS})

endif()

elseif(EXISTS "${d}")

ocv_target_include_directories(${target} "${d}")

endif()

endforeach()

endmacro()

macro(ocv_module_include_directories)

ocv_target_include_directories(${the_module}

"${OPENCV_MODULE_${the_module}_LOCATION}/include"

"${OPENCV_MODULE_${the_module}_LOCATION}/src"

"${CMAKE_CURRENT_BINARY_DIR}" # for precompiled headers

)

ocv_target_include_modules(${the_module} ${OPENCV_MODULE_${the_module}_DEPS} ${ARGN})

endmacro()

macro(ocv_set_module_sources)

ocv_debug_message("ocv_set_module_sources(" ${ARGN} ")")

set(OPENCV_MODULE_${the_module}_HEADERS "")

set(OPENCV_MODULE_${the_module}_SOURCES "")

foreach(f "HEADERS" ${ARGN})

if(f STREQUAL "HEADERS" OR f STREQUAL "SOURCES")

set(__filesvar "OPENCV_MODULE_${the_module}_${f}")

else()

list(APPEND ${__filesvar} "${f}")

endif()

endforeach()

# the hacky way to embeed any files into the OpenCV without modification of its build system

if(COMMAND ocv_get_module_external_sources)

ocv_get_module_external_sources()

endif()

if(OPENCV_MODULE_${the_module}_SOURCES_DISPATCHED)

list(APPEND OPENCV_MODULE_${the_module}_SOURCES ${OPENCV_MODULE_${the_module}_SOURCES_DISPATCHED})

endif()

# use full paths for module to be independent from the module location

ocv_convert_to_full_paths(OPENCV_MODULE_${the_module}_HEADERS)

set(OPENCV_MODULE_${the_module}_HEADERS ${OPENCV_MODULE_${the_module}_HEADERS} CACHE INTERNAL "List of header files for ${the_module}")

set(OPENCV_MODULE_${the_module}_SOURCES ${OPENCV_MODULE_${the_module}_SOURCES} CACHE INTERNAL "List of source files for ${the_module}")

endmacro()

macro(ocv_glob_module_sources)

ocv_debug_message("ocv_glob_module_sources(" ${ARGN} ")")

set(_argn ${ARGN})

list(FIND _argn "EXCLUDE_CUDA" exclude_cuda)

if(NOT exclude_cuda EQUAL -1)

list(REMOVE_AT _argn ${exclude_cuda})

endif()

file(GLOB_RECURSE lib_srcs

"${CMAKE_CURRENT_LIST_DIR}/src/*.cpp"

)

file(GLOB_RECURSE lib_int_hdrs

"${CMAKE_CURRENT_LIST_DIR}/src/*.hpp"

"${CMAKE_CURRENT_LIST_DIR}/src/*.h"

)

file(GLOB lib_hdrs

"${CMAKE_CURRENT_LIST_DIR}/include/opencv2/*.hpp"

"${CMAKE_CURRENT_LIST_DIR}/include/opencv2/${name}/*.hpp"

"${CMAKE_CURRENT_LIST_DIR}/include/opencv2/${name}/*.h"

"${CMAKE_CURRENT_LIST_DIR}/include/opencv2/${name}/hal/*.hpp"

"${CMAKE_CURRENT_LIST_DIR}/include/opencv2/${name}/hal/*.h"

"${CMAKE_CURRENT_LIST_DIR}/include/opencv2/${name}/utils/*.hpp"

"${CMAKE_CURRENT_LIST_DIR}/include/opencv2/${name}/utils/*.h"

)

file(GLOB lib_hdrs_detail

"${CMAKE_CURRENT_LIST_DIR}/include/opencv2/${name}/detail/*.hpp"

"${CMAKE_CURRENT_LIST_DIR}/include/opencv2/${name}/detail/*.h"

)

if (APPLE)

file(GLOB_RECURSE lib_srcs_apple

"${CMAKE_CURRENT_LIST_DIR}/src/*.mm"

)

list(APPEND lib_srcs ${lib_srcs_apple})

endif()

ocv_source_group("Src" DIRBASE "${CMAKE_CURRENT_LIST_DIR}/src" FILES ${lib_srcs} ${lib_int_hdrs})

ocv_source_group("Include" DIRBASE "${CMAKE_CURRENT_LIST_DIR}/include" FILES ${lib_hdrs} ${lib_hdrs_detail})

set(lib_cuda_srcs "")

set(lib_cuda_hdrs "")

if(HAVE_CUDA AND exclude_cuda EQUAL -1)

file(GLOB lib_cuda_srcs

"${CMAKE_CURRENT_LIST_DIR}/src/cuda/*.cu"

)

file(GLOB lib_cuda_hdrs

"${CMAKE_CURRENT_LIST_DIR}/src/cuda/*.hpp"

)

source_group("Src\\Cuda" FILES ${lib_cuda_srcs} ${lib_cuda_hdrs})

endif()

file(GLOB cl_kernels

"${CMAKE_CURRENT_LIST_DIR}/src/opencl/*.cl"

)

if(cl_kernels)

set(OCL_NAME opencl_kernels_${name})

add_custom_command(

OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/${OCL_NAME}.cpp" # don't add .hpp file here to optimize build process

COMMAND ${CMAKE_COMMAND} "-DMODULE_NAME=${name}" "-DCL_DIR=${CMAKE_CURRENT_LIST_DIR}/src/opencl" "-DOUTPUT=${CMAKE_CURRENT_BINARY_DIR}/${OCL_NAME}.cpp" -P "${OpenCV_SOURCE_DIR}/cmake/cl2cpp.cmake"

DEPENDS ${cl_kernels} "${OpenCV_SOURCE_DIR}/cmake/cl2cpp.cmake"

COMMENT "Processing OpenCL kernels (${name})"

)

ocv_source_group("Src\\opencl\\kernels" FILES ${cl_kernels})

ocv_source_group("Src\\opencl\\kernels\\autogenerated" FILES "${CMAKE_CURRENT_BINARY_DIR}/${OCL_NAME}.cpp" "${CMAKE_CURRENT_BINARY_DIR}/${OCL_NAME}.hpp")

set_source_files_properties("${CMAKE_CURRENT_BINARY_DIR}/${OCL_NAME}.cpp" "${CMAKE_CURRENT_BINARY_DIR}/${OCL_NAME}.hpp"

PROPERTIES GENERATED TRUE

)

list(APPEND lib_srcs ${cl_kernels} "${CMAKE_CURRENT_BINARY_DIR}/${OCL_NAME}.cpp" "${CMAKE_CURRENT_BINARY_DIR}/${OCL_NAME}.hpp")

endif()

ocv_set_module_sources(${_argn} HEADERS ${lib_hdrs} ${lib_hdrs_detail}

SOURCES ${lib_srcs} ${lib_int_hdrs} ${lib_cuda_srcs} ${lib_cuda_hdrs})

endmacro()

macro(ocv_create_module)

ocv_debug_message("${the_module}: ocv_create_module(" ${ARGN} ")")

if(NOT " ${ARGN}" STREQUAL " ")

set(OPENCV_MODULE_${the_module}_LINK_DEPS "${OPENCV_MODULE_${the_module}_LINK_DEPS};${ARGN}" CACHE INTERNAL "")

endif()

if(${BUILD_opencv_world} AND OPENCV_MODULE_${the_module}_IS_PART_OF_WORLD)

# nothing

set(the_module_target opencv_world)

else()

_ocv_create_module(${ARGN})

set(the_module_target ${the_module})

endif()

if(WINRT)

# removing APPCONTAINER from modules to run from console

# in case of usual starting of WinRT test apps output is missing

# so starting of console version w/o APPCONTAINER is required to get test results

# also this allows to use opencv_extra test data for these tests

if(NOT "${the_module}" STREQUAL "opencv_ts" AND NOT "${the_module}" STREQUAL "opencv_hal")

add_custom_command(TARGET ${the_module}

POST_BUILD

COMMAND link.exe /edit /APPCONTAINER:NO $(TargetPath))

endif()

if("${the_module}" STREQUAL "opencv_ts")

# copy required dll files; WinRT apps need these dlls that are usually substituted by Visual Studio

# however they are not on path and need to be placed with executables to run from console w/o APPCONTAINER

add_custom_command(TARGET ${the_module}

POST_BUILD

COMMAND copy /y "\"$(VCInstallDir)redist\\$(PlatformTarget)\\Microsoft.VC$(PlatformToolsetVersion).CRT\\msvcp$(PlatformToolsetVersion).dll\"" "\"${CMAKE_BINARY_DIR}\\bin\\$(Configuration)\\msvcp$(PlatformToolsetVersion)_app.dll\""

COMMAND copy /y "\"$(VCInstallDir)redist\\$(PlatformTarget)\\Microsoft.VC$(PlatformToolsetVersion).CRT\\msvcr$(PlatformToolsetVersion).dll\"" "\"${CMAKE_BINARY_DIR}\\bin\\$(Configuration)\\msvcr$(PlatformToolsetVersion)_app.dll\""

COMMAND copy /y "\"$(VCInstallDir)redist\\$(PlatformTarget)\\Microsoft.VC$(PlatformToolsetVersion).CRT\\vccorlib$(PlatformToolsetVersion).dll\"" "\"${CMAKE_BINARY_DIR}\\bin\\$(Configuration)\\vccorlib$(PlatformToolsetVersion)_app.dll\"")

endif()

endif()

endmacro()

macro(_ocv_create_module)

ocv_compiler_optimization_process_sources(OPENCV_MODULE_${the_module}_SOURCES OPENCV_MODULE_${the_module}_DEPS_EXT ${the_module})

set(OPENCV_MODULE_${the_module}_HEADERS ${OPENCV_MODULE_${the_module}_HEADERS} CACHE INTERNAL "List of header files for ${the_module}")

set(OPENCV_MODULE_${the_module}_SOURCES ${OPENCV_MODULE_${the_module}_SOURCES} CACHE INTERNAL "List of source files for ${the_module}")

# The condition we ought to be testing here is whether ocv_add_precompiled_headers will

# be called at some point in the future. We can't look into the future, though,

# so this will have to do.

if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/precomp.hpp" AND NOT ${the_module} STREQUAL opencv_world)

get_native_precompiled_header(${the_module} precomp.hpp)

endif()

if(WIN32

AND (BUILD_SHARED_LIBS AND NOT "x${OPENCV_MODULE_TYPE}" STREQUAL "xSTATIC")

AND NOT OPENCV_VS_VERSIONINFO_SKIP)

if(DEFINED OPENCV_VS_VERSIONINFO_FILE)

set(_VS_VERSION_FILE "${OPENCV_VS_VERSIONINFO_FILE}")

elseif(DEFINED OPENCV_VS_VERSIONINFO_${the_module}_FILE)

set(_VS_VERSION_FILE "${OPENCV_VS_VERSIONINFO_${the_module}_FILE}")

elseif(NOT OPENCV_VS_VERSIONINFO_SKIP_GENERATION)

set(_VS_VERSION_FILE "${CMAKE_CURRENT_BINARY_DIR}/vs_version.rc")

ocv_generate_vs_version_file("${_VS_VERSION_FILE}"

NAME "${the_module}"

FILEDESCRIPTION "OpenCV module: ${OPENCV_MODULE_${the_module}_DESCRIPTION}"

INTERNALNAME "${the_module}${OPENCV_DLLVERSION}"

ORIGINALFILENAME "${the_module}${OPENCV_DLLVERSION}.dll"

)

endif()

if(_VS_VERSION_FILE)

if(NOT EXISTS "${_VS_VERSION_FILE}")

message(STATUS "${the_module}: Required .rc file is missing: ${_VS_VERSION_FILE}")

endif()

source_group("Src" FILES "${_VS_VERSION_FILE}")

endif()

endif()

source_group("Include" FILES "${OPENCV_CONFIG_FILE_INCLUDE_DIR}/cvconfig.h" "${OPENCV_CONFIG_FILE_INCLUDE_DIR}/opencv2/opencv_modules.hpp")

source_group("Src" FILES "${${the_module}_pch}")

ocv_add_library(${the_module} ${OPENCV_MODULE_TYPE} ${OPENCV_MODULE_${the_module}_HEADERS} ${OPENCV_MODULE_${the_module}_SOURCES}

"${OPENCV_CONFIG_FILE_INCLUDE_DIR}/cvconfig.h" "${OPENCV_CONFIG_FILE_INCLUDE_DIR}/opencv2/opencv_modules.hpp"

${${the_module}_pch}

${_VS_VERSION_FILE}

)

set_target_properties(${the_module} PROPERTIES LABELS "${OPENCV_MODULE_${the_module}_LABEL};Module")

set_source_files_properties(${OPENCV_MODULE_${the_module}_HEADERS} ${OPENCV_MODULE_${the_module}_SOURCES} ${${the_module}_pch}

PROPERTIES LABELS "${OPENCV_MODULE_${the_module}_LABEL};Module")

ocv_target_link_libraries(${the_module} LINK_PUBLIC ${OPENCV_MODULE_${the_module}_DEPS_TO_LINK})

ocv_target_link_libraries(${the_module} LINK_PUBLIC ${OPENCV_MODULE_${the_module}_DEPS_EXT})

ocv_target_link_libraries(${the_module} LINK_PRIVATE ${OPENCV_LINKER_LIBS} ${OPENCV_HAL_LINKER_LIBS} ${IPP_LIBS} ${ARGN})

if (HAVE_CUDA)

ocv_target_link_libraries(${the_module} LINK_PRIVATE ${CUDA_LIBRARIES} ${CUDA_npp_LIBRARY})

endif()

if(OPENCV_MODULE_${the_module}_COMPILE_DEFINITIONS)

target_compile_definitions(${the_module} ${OPENCV_MODULE_${the_module}_COMPILE_DEFINITIONS})

unset(OPENCV_MODULE_${the_module}_COMPILE_DEFINITIONS CACHE)

endif()

add_dependencies(opencv_modules ${the_module})

if(ENABLE_SOLUTION_FOLDERS)

set_target_properties(${the_module} PROPERTIES FOLDER "modules")

endif()

set_target_properties(${the_module} PROPERTIES

OUTPUT_NAME "${the_module}${OPENCV_DLLVERSION}"

DEBUG_POSTFIX "${OPENCV_DEBUG_POSTFIX}"

COMPILE_PDB_NAME "${the_module}${OPENCV_DLLVERSION}"

COMPILE_PDB_NAME_DEBUG "${the_module}${OPENCV_DLLVERSION}${OPENCV_DEBUG_POSTFIX}"

ARCHIVE_OUTPUT_DIRECTORY ${LIBRARY_OUTPUT_PATH}

COMPILE_PDB_OUTPUT_DIRECTORY ${LIBRARY_OUTPUT_PATH}

LIBRARY_OUTPUT_DIRECTORY ${LIBRARY_OUTPUT_PATH}

RUNTIME_OUTPUT_DIRECTORY ${EXECUTABLE_OUTPUT_PATH}

DEFINE_SYMBOL CVAPI_EXPORTS

)

if(ANDROID AND BUILD_FAT_JAVA_LIB)

target_compile_definitions(${the_module} PRIVATE CVAPI_EXPORTS)

endif()

# For dynamic link numbering convenions

if(NOT ANDROID)

# Android SDK build scripts can include only .so files into final .apk

# As result we should not set version properties for Android

set_target_properties(${the_module} PROPERTIES

VERSION ${OPENCV_LIBVERSION}

SOVERSION ${OPENCV_SOVERSION}

)

endif()

if (ENABLE_GNU_STL_DEBUG)

target_compile_definitions(${the_module} PUBLIC _GLIBCXX_DEBUG)

endif()

if(MSVC)

if(CMAKE_CROSSCOMPILING)

set_target_properties(${the_module} PROPERTIES LINK_FLAGS "/NODEFAULTLIB:secchk")

endif()

set_target_properties(${the_module} PROPERTIES LINK_FLAGS "/NODEFAULTLIB:libc /DEBUG")

endif()

get_target_property(_target_type ${the_module} TYPE)

if(OPENCV_MODULE_${the_module}_CLASS STREQUAL "PUBLIC" AND

("${_target_type}" STREQUAL "SHARED_LIBRARY" OR (NOT BUILD_SHARED_LIBS OR NOT INSTALL_CREATE_DISTRIB)))

ocv_install_target(${the_module} EXPORT OpenCVModules OPTIONAL

RUNTIME DESTINATION ${OPENCV_BIN_INSTALL_PATH} COMPONENT libs

LIBRARY DESTINATION ${OPENCV_LIB_INSTALL_PATH} COMPONENT libs NAMELINK_SKIP

ARCHIVE DESTINATION ${OPENCV_LIB_INSTALL_PATH} COMPONENT dev

)

endif()

if("${_target_type}" STREQUAL "SHARED_LIBRARY")

install(TARGETS ${the_module}

LIBRARY DESTINATION ${OPENCV_LIB_INSTALL_PATH} COMPONENT dev NAMELINK_ONLY)

endif()

# only "public" headers need to be installed

if(OPENCV_MODULE_${the_module}_HEADERS AND ";${OPENCV_MODULES_PUBLIC};" MATCHES ";${the_module};")

foreach(hdr ${OPENCV_MODULE_${the_module}_HEADERS})

string(REGEX REPLACE "^.*opencv2/" "opencv2/" hdr2 "${hdr}")

if(NOT hdr2 MATCHES "private" AND hdr2 MATCHES "^(opencv2/?.*)/[^/]+.h(..)?$" )

install(FILES ${hdr} OPTIONAL DESTINATION "${OPENCV_INCLUDE_INSTALL_PATH}/${CMAKE_MATCH_1}" COMPONENT dev)

endif()

endforeach()

endif()

_ocv_add_precompiled_headers(${the_module})

endmacro()

macro(_ocv_add_precompiled_headers the_target)

ocv_debug_message("ocv_add_precompiled_headers(" ${the_target} ${ARGN} ")")

if("${the_target}" MATCHES "^opencv_test_.*$")

SET(pch_path "test/test_")

elseif("${the_target}" MATCHES "^opencv_perf_.*$")

SET(pch_path "perf/perf_")

else()

SET(pch_path "src/")

endif()

ocv_add_precompiled_header_to_target(${the_target} "${CMAKE_CURRENT_SOURCE_DIR}/${pch_path}precomp.hpp")

unset(pch_path)

endmacro()

macro(ocv_define_module module_name)

ocv_debug_message("ocv_define_module(" ${module_name} ${ARGN} ")")

set(_argn ${ARGN})

set(exclude_cuda "")

foreach(arg ${_argn})

if("${arg}" STREQUAL "EXCLUDE_CUDA")

set(exclude_cuda "${arg}")

list(REMOVE_ITEM _argn ${arg})

endif()

endforeach()

ocv_add_module(${module_name} ${_argn})

ocv_glob_module_sources(${exclude_cuda})

ocv_module_include_directories()

ocv_create_module()

ocv_add_accuracy_tests()

ocv_add_perf_tests()

ocv_add_samples()

endmacro()

macro(ocv_check_dependencies)

set(OCV_DEPENDENCIES_FOUND TRUE)

foreach(d ${ARGN})

if(d MATCHES "^opencv_[^ ]+$" AND NOT HAVE_${d})

set(OCV_DEPENDENCIES_FOUND FALSE)

break()

endif()

endforeach()

endmacro()

macro(__ocv_parse_test_sources tests_type)

set(OPENCV_${tests_type}_${the_module}_SOURCES "")

set(OPENCV_${tests_type}_${the_module}_DEPS "")

set(__file_group_name "")