cmake/OpenCVUtils.cmake

   1 include(CMakeParseArguments)
   2
   3 # Debugging function
   4 function(ocv_cmake_dump_vars)
   5   set(OPENCV_SUPPRESS_DEPRECATIONS 1)  # suppress deprecation warnings from variable_watch() guards
   6   get_cmake_property(__variableNames VARIABLES)
   7   cmake_parse_arguments(DUMP "" "TOFILE" "" ${ARGN})
   8   set(regex "${DUMP_UNPARSED_ARGUMENTS}")
   9   string(TOLOWER "${regex}" regex_lower)
  10   set(__VARS "")
  11   foreach(__variableName ${__variableNames})
  12     string(TOLOWER "${__variableName}" __variableName_lower)
  13     if((__variableName MATCHES "${regex}" OR __variableName_lower MATCHES "${regex_lower}")
  14         AND NOT __variableName_lower MATCHES "^__")
  15       set(__VARS "${__VARS}${__variableName}=${${__variableName}}\n")
  16     endif()
  17   endforeach()
  18   if(DUMP_TOFILE)
  19     file(WRITE ${CMAKE_BINARY_DIR}/${DUMP_TOFILE} "${__VARS}")
  20   else()
  21     message(AUTHOR_WARNING "${__VARS}")
  22   endif()
  23 endfunction()
  24
  25
  26 #
  27 # CMake script hooks support
  28 #
  29 option(OPENCV_DUMP_HOOKS_FLOW "Dump called OpenCV hooks" OFF)
  30 macro(ocv_cmake_hook_append hook_name)
  31   set(__var_name "__OPENCV_CMAKE_HOOKS_${hook_name}")
  32   set(__value "${${__var_name}}")
  33   message(STATUS "Registering hook '${hook_name}': ${ARGN}")
  34   list(APPEND __value ${ARGN})
  35   set(${__var_name} "${__value}" CACHE INTERNAL "")
  36 endmacro()
  37 macro(ocv_cmake_hook hook_name)
  38   set(__var_name "__OPENCV_CMAKE_HOOKS_${hook_name}")
  39   if(OPENCV_DUMP_HOOKS_FLOW)
  40     message(STATUS "Hook ${hook_name} ...")
  41   endif()
  42   foreach(__hook ${${__var_name}})
  43     #message(STATUS "Hook ${hook_name}: calling '${__hook}' ...")
  44     if(COMMAND "${__hook}")
  45       message(FATAL_ERROR "Indirect calling of CMake commands is not supported yet")
  46     else()
  47       include("${__hook}")
  48     endif()
  49   endforeach()
  50 endmacro()
  51 macro(ocv_cmake_reset_hooks)
  52   get_cmake_property(__variableNames VARIABLES)
  53   foreach(__variableName ${__variableNames})
  54     if(__variableName MATCHES "^__OPENCV_CMAKE_HOOKS_")
  55       unset(${__variableName})
  56       unset(${__variableName} CACHE)
  57     endif()
  58   endforeach()
  59 endmacro()
  60 macro(ocv_cmake_hook_register_dir dir)
  61   file(GLOB hook_files RELATIVE "${dir}" "${dir}/*.cmake")
  62   foreach(f ${hook_files})
  63     if(f MATCHES "^(.+)\\.cmake$")
  64       set(hook_name "${CMAKE_MATCH_1}")
  65       ocv_cmake_hook_append(${hook_name} "${dir}/${f}")
  66     endif()
  67   endforeach()
  68 endmacro()
  69
  70
  71 function(ocv_cmake_eval var_name)
  72   if(DEFINED ${var_name})
  73     file(WRITE "${CMAKE_BINARY_DIR}/CMakeCommand-${var_name}.cmake" ${${var_name}})
  74     include("${CMAKE_BINARY_DIR}/CMakeCommand-${var_name}.cmake")
  75   endif()
  76   if(";${ARGN};" MATCHES ";ONCE;")
  77     unset(${var_name} CACHE)
  78   endif()
  79 endfunction()
  80
  81 macro(ocv_cmake_configure file_name var_name)
  82   file(READ "${file_name}" __config)
  83   string(CONFIGURE "${__config}" ${var_name} ${ARGN})
  84 endmacro()
  85
  86 macro(ocv_update VAR)
  87   if(NOT DEFINED ${VAR})
  88     if("x${ARGN}" STREQUAL "x")
  89       set(${VAR} "")
  90     else()
  91       set(${VAR} ${ARGN})
  92     endif()
  93   else()
  94     #ocv_debug_message("Preserve old value for ${VAR}: ${${VAR}}")
  95   endif()
  96 endmacro()
  97
  98 # Search packages for the host system instead of packages for the target system
  99 # in case of cross compilation these macros should be defined by the toolchain file
 100 if(NOT COMMAND find_host_package)
 101   macro(find_host_package)
 102     find_package(${ARGN})
 103   endmacro()
 104 endif()
 105 if(NOT COMMAND find_host_program)
 106   macro(find_host_program)
 107     find_program(${ARGN})
 108   endmacro()
 109 endif()
 110
 111 # assert macro
 112 # Note: it doesn't support lists in arguments
 113 # Usage samples:
 114 #   ocv_assert(MyLib_FOUND)
 115 #   ocv_assert(DEFINED MyLib_INCLUDE_DIRS)
 116 macro(ocv_assert)
 117   if(NOT (${ARGN}))
 118     string(REPLACE ";" " " __assert_msg "${ARGN}")
 119     message(AUTHOR_WARNING "Assertion failed: ${__assert_msg}")
 120   endif()
 121 endmacro()
 122
 123 macro(ocv_debug_message)
 124 #  string(REPLACE ";" " " __msg "${ARGN}")
 125 #  message(STATUS "${__msg}")
 126 endmacro()
 127
 128 macro(ocv_check_environment_variables)
 129   foreach(_var ${ARGN})
 130     if(" ${${_var}}" STREQUAL " " AND DEFINED ENV{${_var}})
 131       set(__value "$ENV{${_var}}")
 132       file(TO_CMAKE_PATH "${__value}" __value) # Assume that we receive paths
 133       set(${_var} "${__value}")
 134       message(STATUS "Update variable ${_var} from environment: ${${_var}}")
 135     endif()
 136   endforeach()
 137 endmacro()
 138
 139 macro(ocv_path_join result_var P1 P2_)
 140   string(REGEX REPLACE "^[/]+" "" P2 "${P2_}")
 141   if("${P1}" STREQUAL "" OR "${P1}" STREQUAL ".")
 142     set(${result_var} "${P2}")
 143   elseif("${P1}" STREQUAL "/")
 144     set(${result_var} "/${P2}")
 145   elseif("${P2}" STREQUAL "")
 146     set(${result_var} "${P1}")
 147   else()
 148     set(${result_var} "${P1}/${P2}")
 149   endif()
 150   string(REGEX REPLACE "([/\\]?)[\\.][/\\]" "\\1" ${result_var} "${${result_var}}")
 151   if("${${result_var}}" STREQUAL "")
 152     set(${result_var} ".")
 153   endif()
 154   #message(STATUS "'${P1}' '${P2_}' => '${${result_var}}'")
 155 endmacro()
 156
 157
 158 # Used to parse Android SDK 'source.properties' files
 159 # File lines format:
 160 # - '<var_name>=<value>' (with possible 'space' symbols around '=')
 161 # - '#<any comment>'
 162 # Parsed values are saved into CMake variables:
 163 # - '${var_prefix}_${var_name}'
 164 # Flags:
 165 # - 'CACHE_VAR <var1> <var2>' - put these properties into CMake internal cache
 166 # - 'MSG_PREFIX <msg>' - prefix string for emitted messages
 167 # - flag 'VALIDATE' - emit messages about missing values from required cached variables
 168 # - flag 'WARNING' - emit CMake WARNING instead of STATUS messages
 169 function(ocv_parse_properties_file file var_prefix)
 170   cmake_parse_arguments(PARSE_PROPERTIES_PARAM "VALIDATE;WARNING" "" "CACHE_VAR;MSG_PREFIX" ${ARGN})
 171
 172   set(__msg_type STATUS)
 173   if(PARSE_PROPERTIES_PARAM_WARNING)
 174     set(__msg_type WARNING)
 175   endif()
 176
 177   if(EXISTS "${file}")
 178     set(SOURCE_PROPERTIES_REGEX "^[ ]*([^=:\n\"' ]+)[ ]*=[ ]*(.*)$")
 179     file(STRINGS "${file}" SOURCE_PROPERTIES_LINES REGEX "^[ ]*[^#].*$")
 180     foreach(line ${SOURCE_PROPERTIES_LINES})
 181       if(line MATCHES "${SOURCE_PROPERTIES_REGEX}")
 182         set(__name "${CMAKE_MATCH_1}")
 183         set(__value "${CMAKE_MATCH_2}")
 184         string(REGEX REPLACE "[^a-zA-Z0-9_]" "_" __name ${__name})
 185         if(";${PARSE_PROPERTIES_PARAM_CACHE_VAR};" MATCHES ";${__name};")
 186           set(${var_prefix}_${__name} "${__value}" CACHE INTERNAL "from ${file}")
 187         else()
 188           set(${var_prefix}_${__name} "${__value}" PARENT_SCOPE)
 189         endif()
 190       else()
 191         message(${__msg_type} "${PARSE_PROPERTIES_PARAM_MSG_PREFIX}Can't parse source property: '${line}' (from ${file})")
 192       endif()
 193     endforeach()
 194     if(PARSE_PROPERTIES_PARAM_VALIDATE)
 195       set(__missing "")
 196       foreach(__name ${PARSE_PROPERTIES_PARAM_CACHE_VAR})
 197         if(NOT DEFINED ${var_prefix}_${__name})
 198           list(APPEND __missing ${__name})
 199         endif()
 200       endforeach()
 201       if(__missing)
 202         message(${__msg_type} "${PARSE_PROPERTIES_PARAM_MSG_PREFIX}Can't read properties '${__missing}' from '${file}'")
 203       endif()
 204     endif()
 205   else()
 206     message(${__msg_type} "${PARSE_PROPERTIES_PARAM_MSG_PREFIX}Can't find file: ${file}")
 207   endif()
 208 endfunction()
 209
 210
 211
 212 # rename modules target to world if needed
 213 macro(_ocv_fix_target target_var)
 214   if(BUILD_opencv_world)
 215     if(OPENCV_MODULE_${${target_var}}_IS_PART_OF_WORLD)
 216       set(${target_var} opencv_world)
 217     endif()
 218   endif()
 219 endmacro()
 220
 221
 222 # check if "sub" (file or dir) is below "dir"
 223 function(ocv_is_subdir res dir sub )
 224   get_filename_component(dir "${dir}" ABSOLUTE)
 225   get_filename_component(sub "${sub}" ABSOLUTE)
 226   file(TO_CMAKE_PATH "${dir}" dir)
 227   file(TO_CMAKE_PATH "${sub}" sub)
 228   set(dir "${dir}/")
 229   string(LENGTH "${dir}" len)
 230   string(LENGTH "${sub}" len_sub)
 231   if(NOT len GREATER len_sub)
 232     string(SUBSTRING "${sub}" 0 ${len} prefix)
 233   endif()
 234   if(prefix AND prefix STREQUAL dir)
 235     set(${res} TRUE PARENT_SCOPE)
 236   else()
 237     set(${res} FALSE PARENT_SCOPE)
 238   endif()
 239 endfunction()
 240
 241
 242 function(ocv_is_opencv_directory result_var dir)
 243   set(result FALSE)
 244   foreach(parent ${OpenCV_SOURCE_DIR} ${OpenCV_BINARY_DIR} ${OPENCV_EXTRA_MODULES_PATH})
 245     ocv_is_subdir(result "${parent}" "${dir}")
 246     if(result)
 247       break()
 248     endif()
 249   endforeach()
 250   set(${result_var} ${result} PARENT_SCOPE)
 251 endfunction()
 252
 253
 254 # adds include directories in such a way that directories from the OpenCV source tree go first
 255 function(ocv_include_directories)
 256   ocv_debug_message("ocv_include_directories( ${ARGN} )")
 257   set(__add_before "")
 258   foreach(dir ${ARGN})
 259     ocv_is_opencv_directory(__is_opencv_dir "${dir}")
 260     if(__is_opencv_dir)
 261       list(APPEND __add_before "${dir}")
 262     elseif(CV_GCC AND NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS "6.0" AND
 263            dir MATCHES "/usr/include$")
 264       # workaround for GCC 6.x bug
 265     else()
 266       include_directories(AFTER SYSTEM "${dir}")
 267     endif()
 268   endforeach()
 269   include_directories(BEFORE ${__add_before})
 270 endfunction()
 271
 272 function(ocv_append_target_property target prop)
 273   get_target_property(val ${target} ${prop})
 274   if(val)
 275     set(val "${val} ${ARGN}")
 276     set_target_properties(${target} PROPERTIES ${prop} "${val}")
 277   else()
 278     set_target_properties(${target} PROPERTIES ${prop} "${ARGN}")
 279   endif()
 280 endfunction()
 281
 282 function(ocv_append_dependant_targets target)
 283   #ocv_debug_message("ocv_append_dependant_targets(${target} ${ARGN})")
 284   _ocv_fix_target(target)
 285   set(OPENCV_DEPENDANT_TARGETS_${target} "${OPENCV_DEPENDANT_TARGETS_${target}};${ARGN}" CACHE INTERNAL "" FORCE)
 286 endfunction()
 287
 288 # adds include directories in such a way that directories from the OpenCV source tree go first
 289 function(ocv_target_include_directories target)
 290   #ocv_debug_message("ocv_target_include_directories(${target} ${ARGN})")
 291   _ocv_fix_target(target)
 292   set(__params "")
 293   if(CV_GCC AND NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS "6.0" AND
 294       ";${ARGN};" MATCHES "/usr/include;")
 295     return() # workaround for GCC 6.x bug
 296   endif()
 297   set(__params "")
 298   set(__system_params "")
 299   set(__var_name __params)
 300   foreach(dir ${ARGN})
 301     if("${dir}" STREQUAL "SYSTEM")
 302       set(__var_name __system_params)
 303     else()
 304       get_filename_component(__abs_dir "${dir}" ABSOLUTE)
 305       ocv_is_opencv_directory(__is_opencv_dir "${dir}")
 306       if(__is_opencv_dir)
 307         list(APPEND ${__var_name} "${__abs_dir}")
 308       else()
 309         list(APPEND ${__var_name} "${dir}")
 310       endif()
 311     endif()
 312   endforeach()
 313   if(HAVE_CUDA OR CMAKE_VERSION VERSION_LESS 2.8.11)
 314     include_directories(${__params})
 315     include_directories(SYSTEM ${__system_params})
 316   else()
 317     if(TARGET ${target})
 318       if(__params)
 319         target_include_directories(${target} PRIVATE ${__params})
 320         if(OPENCV_DEPENDANT_TARGETS_${target})
 321           foreach(t ${OPENCV_DEPENDANT_TARGETS_${target}})
 322             target_include_directories(${t} PRIVATE ${__params})
 323           endforeach()
 324         endif()
 325       endif()
 326       if(__system_params)
 327         target_include_directories(${target} SYSTEM PRIVATE ${__system_params})
 328         if(OPENCV_DEPENDANT_TARGETS_${target})
 329           foreach(t ${OPENCV_DEPENDANT_TARGETS_${target}})
 330             target_include_directories(${t} SYSTEM PRIVATE ${__system_params})
 331           endforeach()
 332         endif()
 333       endif()
 334     else()
 335       if(__params)
 336         set(__new_inc ${OCV_TARGET_INCLUDE_DIRS_${target}})
 337         list(APPEND __new_inc ${__params})
 338         set(OCV_TARGET_INCLUDE_DIRS_${target} "${__new_inc}" CACHE INTERNAL "")
 339       endif()
 340       if(__system_params)
 341         set(__new_inc ${OCV_TARGET_INCLUDE_SYSTEM_DIRS_${target}})
 342         list(APPEND __new_inc ${__system_params})
 343         set(OCV_TARGET_INCLUDE_SYSTEM_DIRS_${target} "${__new_inc}" CACHE INTERNAL "")
 344       endif()
 345     endif()
 346   endif()
 347 endfunction()
 348
 349 # clears all passed variables
 350 macro(ocv_clear_vars)
 351   foreach(_var ${ARGN})
 352     unset(${_var})
 353     unset(${_var} CACHE)
 354   endforeach()
 355 endmacro()
 356
 357 set(OCV_COMPILER_FAIL_REGEX
 358     "command line option .* is valid for .* but not for C\\+\\+" # GNU
 359     "command line option .* is valid for .* but not for C" # GNU
 360     "unrecognized .*option"                     # GNU
 361     "unknown .*option"                          # Clang
 362     "ignoring unknown option"                   # MSVC
 363     "warning D9002"                             # MSVC, any lang
 364     "option .*not supported"                    # Intel
 365     "[Uu]nknown option"                         # HP
 366     "[Ww]arning: [Oo]ption"                     # SunPro
 367     "command option .* is not recognized"       # XL
 368     "not supported in this configuration, ignored"       # AIX (';' is replaced with ',')
 369     "File with unknown suffix passed to linker" # PGI
 370     "WARNING: unknown flag:"                    # Open64
 371   )
 372
 373 MACRO(ocv_check_compiler_flag LANG FLAG RESULT)
 374   set(_fname "${ARGN}")
 375   if(NOT DEFINED ${RESULT})
 376     if(_fname)
 377       # nothing
 378     elseif("_${LANG}_" MATCHES "_CXX_")
 379       set(_fname "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/src.cxx")
 380       if("${CMAKE_CXX_FLAGS} ${FLAG} " MATCHES "-Werror " OR "${CMAKE_CXX_FLAGS} ${FLAG} " MATCHES "-Werror=unknown-pragmas ")
 381         FILE(WRITE "${_fname}" "int main() { return 0; }\n")
 382       else()
 383         FILE(WRITE "${_fname}" "#pragma\nint main() { return 0; }\n")
 384       endif()
 385     elseif("_${LANG}_" MATCHES "_C_")
 386       set(_fname "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/src.c")
 387       if("${CMAKE_C_FLAGS} ${FLAG} " MATCHES "-Werror " OR "${CMAKE_C_FLAGS} ${FLAG} " MATCHES "-Werror=unknown-pragmas ")
 388         FILE(WRITE "${_fname}" "int main(void) { return 0; }\n")
 389       else()
 390         FILE(WRITE "${_fname}" "#pragma\nint main(void) { return 0; }\n")
 391       endif()
 392     elseif("_${LANG}_" MATCHES "_OBJCXX_")
 393       set(_fname "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/src.mm")
 394       if("${CMAKE_CXX_FLAGS} ${FLAG} " MATCHES "-Werror " OR "${CMAKE_CXX_FLAGS} ${FLAG} " MATCHES "-Werror=unknown-pragmas ")
 395         FILE(WRITE "${_fname}" "int main() { return 0; }\n")
 396       else()
 397         FILE(WRITE "${_fname}" "#pragma\nint main() { return 0; }\n")
 398       endif()
 399     else()
 400       unset(_fname)
 401     endif()
 402     if(_fname)
 403       if(NOT "x${ARGN}" STREQUAL "x")
 404         file(RELATIVE_PATH __msg "${CMAKE_SOURCE_DIR}" "${ARGN}")
 405         set(__msg " (check file: ${__msg})")
 406       else()
 407         set(__msg "")
 408       endif()
 409       MESSAGE(STATUS "Performing Test ${RESULT}${__msg}")
 410       TRY_COMPILE(${RESULT}
 411         "${CMAKE_BINARY_DIR}"
 412         "${_fname}"
 413         CMAKE_FLAGS "-DCMAKE_EXE_LINKER_FLAGS=${CMAKE_EXE_LINKER_FLAGS}"   # CMP0056 do this on new CMake
 414         COMPILE_DEFINITIONS "${FLAG}"
 415         OUTPUT_VARIABLE OUTPUT)
 416
 417       if(${RESULT})
 418         string(REPLACE ";" "," OUTPUT_LINES "${OUTPUT}")
 419         string(REPLACE "\n" ";" OUTPUT_LINES "${OUTPUT_LINES}")
 420         foreach(_regex ${OCV_COMPILER_FAIL_REGEX})
 421           if(NOT ${RESULT})
 422             break()
 423           endif()
 424           foreach(_line ${OUTPUT_LINES})
 425             if("${_line}" MATCHES "${_regex}")
 426               file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
 427                   "Build output check failed:\n"
 428                   "    Regex: '${_regex}'\n"
 429                   "    Output line: '${_line}'\n")
 430               set(${RESULT} 0)
 431               break()
 432             endif()
 433           endforeach()
 434         endforeach()
 435       endif()
 436
 437       IF(${RESULT})
 438         SET(${RESULT} 1 CACHE INTERNAL "Test ${RESULT}")
 439         MESSAGE(STATUS "Performing Test ${RESULT} - Success")
 440       ELSE(${RESULT})
 441         MESSAGE(STATUS "Performing Test ${RESULT} - Failed")
 442         SET(${RESULT} "" CACHE INTERNAL "Test ${RESULT}")
 443         file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
 444             "Compilation failed:\n"
 445             "    source file: '${_fname}'\n"
 446             "    check option: '${FLAG}'\n"
 447             "===== BUILD LOG =====\n"
 448             "${OUTPUT}\n"
 449             "===== END =====\n\n")
 450       ENDIF(${RESULT})
 451     else()
 452       SET(${RESULT} 0)
 453     endif()
 454   endif()
 455 ENDMACRO()
 456
 457 macro(ocv_check_flag_support lang flag varname base_options)
 458   if(CMAKE_BUILD_TYPE)
 459     set(CMAKE_TRY_COMPILE_CONFIGURATION ${CMAKE_BUILD_TYPE})
 460   endif()
 461
 462   if("_${lang}_" MATCHES "_CXX_")
 463     set(_lang CXX)
 464   elseif("_${lang}_" MATCHES "_C_")
 465     set(_lang C)
 466   elseif("_${lang}_" MATCHES "_OBJCXX_")
 467     set(_lang OBJCXX)
 468   else()
 469     set(_lang ${lang})
 470   endif()
 471
 472   string(TOUPPER "${flag}" ${varname})
 473   string(REGEX REPLACE "^(/|-)" "HAVE_${_lang}_" ${varname} "${${varname}}")
 474   string(REGEX REPLACE " -|-|=| |\\." "_" ${varname} "${${varname}}")
 475
 476   ocv_check_compiler_flag("${_lang}" "${base_options} ${flag}" ${${varname}} ${ARGN})
 477 endmacro()
 478
 479 # turns off warnings
 480 macro(ocv_warnings_disable)
 481   if(NOT ENABLE_NOISY_WARNINGS)
 482     set(_flag_vars "")
 483     set(_msvc_warnings "")
 484     set(_gxx_warnings "")
 485     set(_icc_warnings "")
 486     foreach(arg ${ARGN})
 487       if(arg MATCHES "^CMAKE_")
 488         list(APPEND _flag_vars ${arg})
 489       elseif(arg MATCHES "^/wd")
 490         list(APPEND _msvc_warnings ${arg})
 491       elseif(arg MATCHES "^-W")
 492         list(APPEND _gxx_warnings ${arg})
 493       elseif(arg MATCHES "^-wd" OR arg MATCHES "^-Qwd" OR arg MATCHES "^/Qwd")
 494         list(APPEND _icc_warnings ${arg})
 495       endif()
 496     endforeach()
 497     if(MSVC AND _msvc_warnings AND _flag_vars)
 498       foreach(var ${_flag_vars})
 499         foreach(warning ${_msvc_warnings})
 500           set(${var} "${${var}} ${warning}")
 501         endforeach()
 502       endforeach()
 503     elseif(((CV_GCC OR CV_CLANG) OR (UNIX AND CV_ICC)) AND _gxx_warnings AND _flag_vars)
 504       foreach(var ${_flag_vars})
 505         foreach(warning ${_gxx_warnings})
 506           if(NOT warning MATCHES "^-Wno-")
 507             string(REGEX REPLACE "${warning}(=[^ ]*)?" "" ${var} "${${var}}")
 508             string(REPLACE "-W" "-Wno-" warning "${warning}")
 509           endif()
 510           ocv_check_flag_support(${var} "${warning}" _varname "")
 511           if(${_varname})
 512             set(${var} "${${var}} ${warning}")
 513           endif()
 514         endforeach()
 515       endforeach()
 516     endif()
 517     if(CV_ICC AND _icc_warnings AND _flag_vars)
 518       foreach(var ${_flag_vars})
 519         foreach(warning ${_icc_warnings})
 520           if(UNIX)
 521             string(REPLACE "-Qwd" "-wd" warning "${warning}")
 522           else()
 523             string(REPLACE "-wd" "-Qwd" warning "${warning}")
 524           endif()
 525           ocv_check_flag_support(${var} "${warning}" _varname "")
 526           if(${_varname})
 527             set(${var} "${${var}} ${warning}")
 528           endif()
 529         endforeach()
 530       endforeach()
 531     endif()
 532     unset(_flag_vars)
 533     unset(_msvc_warnings)
 534     unset(_gxx_warnings)
 535     unset(_icc_warnings)
 536   endif(NOT ENABLE_NOISY_WARNINGS)
 537 endmacro()
 538
 539 macro(ocv_append_source_file_compile_definitions source)
 540   get_source_file_property(_value "${source}" COMPILE_DEFINITIONS)
 541   if(_value)
 542     set(_value ${_value} ${ARGN})
 543   else()
 544     set(_value ${ARGN})
 545   endif()
 546   set_source_files_properties("${source}" PROPERTIES COMPILE_DEFINITIONS "${_value}")
 547 endmacro()
 548
 549 macro(add_apple_compiler_options the_module)
 550   ocv_check_flag_support(OBJCXX "-fobjc-exceptions" HAVE_OBJC_EXCEPTIONS "")
 551   if(HAVE_OBJC_EXCEPTIONS)
 552     foreach(source ${OPENCV_MODULE_${the_module}_SOURCES})
 553       if("${source}" MATCHES "\\.mm$")
 554         get_source_file_property(flags "${source}" COMPILE_FLAGS)
 555         if(flags)
 556           set(flags "${_flags} -fobjc-exceptions")
 557         else()
 558           set(flags "-fobjc-exceptions")
 559         endif()
 560
 561         set_source_files_properties("${source}" PROPERTIES COMPILE_FLAGS "${flags}")
 562       endif()
 563     endforeach()
 564   endif()
 565 endmacro()
 566
 567 # Provides an option that the user can optionally select.
 568 # Can accept condition to control when option is available for user.
 569 # Usage:
 570 #   option(<option_variable> "help string describing the option" <initial value or boolean expression> [IF <condition>])
 571 macro(OCV_OPTION variable description value)
 572   set(__value ${value})
 573   set(__condition "")
 574   set(__varname "__value")
 575   foreach(arg ${ARGN})
 576     if(arg STREQUAL "IF" OR arg STREQUAL "if")
 577       set(__varname "__condition")
 578     else()
 579       list(APPEND ${__varname} ${arg})
 580     endif()
 581   endforeach()
 582   unset(__varname)
 583   if(__condition STREQUAL "")
 584     set(__condition 2 GREATER 1)
 585   endif()
 586
 587   if(${__condition})
 588     if(__value MATCHES ";")
 589       if(${__value})
 590         option(${variable} "${description}" ON)
 591       else()
 592         option(${variable} "${description}" OFF)
 593       endif()
 594     elseif(DEFINED ${__value})
 595       if(${__value})
 596         option(${variable} "${description}" ON)
 597       else()
 598         option(${variable} "${description}" OFF)
 599       endif()
 600     else()
 601       option(${variable} "${description}" ${__value})
 602     endif()
 603   else()
 604     if(DEFINED ${variable})
 605       # TODO: message(WARNING "Option will be ignored: ${variable} (=${${variable}})")
 606     endif()
 607     unset(${variable} CACHE)
 608   endif()
 609   unset(__condition)
 610   unset(__value)
 611 endmacro()
 612
 613 # Usage: ocv_append_build_options(HIGHGUI FFMPEG)
 614 macro(ocv_append_build_options var_prefix pkg_prefix)
 615   foreach(suffix INCLUDE_DIRS LIBRARIES LIBRARY_DIRS)
 616     if(${pkg_prefix}_${suffix})
 617       list(APPEND ${var_prefix}_${suffix} ${${pkg_prefix}_${suffix}})
 618       list(REMOVE_DUPLICATES ${var_prefix}_${suffix})
 619     endif()
 620   endforeach()
 621 endmacro()
 622
 623 function(ocv_append_source_files_cxx_compiler_options files_var)
 624   set(__flags "${ARGN}")
 625   ocv_check_flag_support(CXX "${__flags}" __HAVE_COMPILER_OPTIONS_VAR "")
 626   if(${__HAVE_COMPILER_OPTIONS_VAR})
 627     foreach(source ${${files_var}})
 628       if("${source}" MATCHES "\\.(cpp|cc|cxx)$")
 629         get_source_file_property(flags "${source}" COMPILE_FLAGS)
 630         if(flags)
 631           set(flags "${flags} ${__flags}")
 632         else()
 633           set(flags "${__flags}")
 634         endif()
 635         set_source_files_properties("${source}" PROPERTIES COMPILE_FLAGS "${flags}")
 636       endif()
 637     endforeach()
 638   endif()
 639 endfunction()
 640
 641 # Usage is similar to CMake 'pkg_check_modules' command
 642 # It additionally controls HAVE_${define} and ${define}_${modname}_FOUND variables
 643 macro(ocv_check_modules define)
 644   unset(HAVE_${define})
 645   foreach(m ${ARGN})
 646     if (m MATCHES "(.*[^><])(>=|=|<=)(.*)")
 647       set(__modname "${CMAKE_MATCH_1}")
 648     else()
 649       set(__modname "${m}")
 650     endif()
 651     unset(${define}_${__modname}_FOUND)
 652   endforeach()
 653   pkg_check_modules(${define} ${ARGN})
 654   if(${define}_FOUND)
 655     set(HAVE_${define} 1)
 656   endif()
 657   foreach(m ${ARGN})
 658     if (m MATCHES "(.*[^><])(>=|=|<=)(.*)")
 659       set(__modname "${CMAKE_MATCH_1}")
 660     else()
 661       set(__modname "${m}")
 662     endif()
 663     if(NOT DEFINED ${define}_${__modname}_FOUND AND ${define}_FOUND)
 664       set(${define}_${__modname}_FOUND 1)
 665     endif()
 666   endforeach()
 667 endmacro()
 668
 669
 670 # Macro that checks if module has been installed.
 671 # After it adds module to build and define
 672 # constants passed as second arg
 673 macro(CHECK_MODULE module_name define cv_module)
 674   set(${define} 0)
 675   if(PKG_CONFIG_FOUND)
 676     set(ALIAS               ALIASOF_${module_name})
 677     set(ALIAS_FOUND                 ${ALIAS}_FOUND)
 678     set(ALIAS_INCLUDE_DIRS   ${ALIAS}_INCLUDE_DIRS)
 679     set(ALIAS_LIBRARY_DIRS   ${ALIAS}_LIBRARY_DIRS)
 680     set(ALIAS_LIBRARIES         ${ALIAS}_LIBRARIES)
 681
 682     PKG_CHECK_MODULES(${ALIAS} ${module_name})
 683     if(${ALIAS_FOUND})
 684       set(${define} 1)
 685       ocv_append_build_options(${cv_module} ${ALIAS})
 686     endif()
 687   endif()
 688 endmacro()
 689
 690 if(NOT DEFINED CMAKE_ARGC) # Guard CMake standalone invocations
 691
 692 # Use this option carefully, CMake's install() will install symlinks instead of real files
 693 # It is fine for development, but should not be used by real installations
 694 set(__symlink_default OFF)  # preprocessing is required for old CMake like 2.8.12
 695 if(DEFINED ENV{BUILD_USE_SYMLINKS})
 696   set(__symlink_default $ENV{BUILD_USE_SYMLINKS})
 697 endif()
 698 OCV_OPTION(BUILD_USE_SYMLINKS "Use symlinks instead of files copying during build (and !!INSTALL!!)" (${__symlink_default}) IF (UNIX OR DEFINED __symlink_default))
 699
 700 if(CMAKE_VERSION VERSION_LESS "3.2")
 701   macro(ocv_cmake_byproducts var_name)
 702     set(${var_name}) # nothing
 703   endmacro()
 704 else()
 705   macro(ocv_cmake_byproducts var_name)
 706     set(${var_name} BYPRODUCTS ${ARGN})
 707   endmacro()
 708 endif()
 709
 710 set(OPENCV_DEPHELPER "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/dephelper" CACHE INTERNAL "")
 711 file(MAKE_DIRECTORY ${OPENCV_DEPHELPER})
 712
 713 if(BUILD_USE_SYMLINKS)
 714   set(__file0 "${CMAKE_CURRENT_LIST_FILE}")
 715   set(__file1 "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/symlink_test")
 716   if(NOT IS_SYMLINK "${__file1}")
 717     execute_process(COMMAND ${CMAKE_COMMAND} -E create_symlink "${__file0}" "${__file1}"
 718         RESULT_VARIABLE SYMLINK_RESULT)
 719     if(NOT SYMLINK_RESULT EQUAL 0)
 720       file(REMOVE "${__file1}")
 721     endif()
 722     if(NOT IS_SYMLINK "${__file1}")
 723       set(BUILD_USE_SYMLINKS 0 CACHE INTERNAL "")
 724     endif()
 725   endif()
 726   if(NOT BUILD_USE_SYMLINKS)
 727     message(STATUS "Build symlinks are not available (disabled)")
 728   endif()
 729 endif()
 730
 731 set(OPENCV_BUILD_INFO_STR "" CACHE INTERNAL "")
 732 function(ocv_output_status msg)
 733   message(STATUS "${msg}")
 734   string(REPLACE "\\" "\\\\" msg "${msg}")
 735   string(REPLACE "\"" "\\\"" msg "${msg}")
 736   set(OPENCV_BUILD_INFO_STR "${OPENCV_BUILD_INFO_STR}\"${msg}\\n\"\n" CACHE INTERNAL "")
 737 endfunction()
 738
 739 macro(ocv_finalize_status)
 740   set(OPENCV_BUILD_INFO_FILE "${CMAKE_BINARY_DIR}/version_string.tmp")
 741   if(EXISTS "${OPENCV_BUILD_INFO_FILE}")
 742     file(READ "${OPENCV_BUILD_INFO_FILE}" __content)
 743   else()
 744     set(__content "")
 745   endif()
 746   if("${__content}" STREQUAL "${OPENCV_BUILD_INFO_STR}")
 747     #message(STATUS "${OPENCV_BUILD_INFO_FILE} contains the same content")
 748   else()
 749     file(WRITE "${OPENCV_BUILD_INFO_FILE}" "${OPENCV_BUILD_INFO_STR}")
 750   endif()
 751   unset(__content)
 752   unset(OPENCV_BUILD_INFO_STR CACHE)
 753
 754   if(NOT OPENCV_SKIP_STATUS_FINALIZATION)
 755     if(DEFINED OPENCV_MODULE_opencv_core_BINARY_DIR)
 756       execute_process(COMMAND ${CMAKE_COMMAND} -E copy_if_different "${OPENCV_BUILD_INFO_FILE}" "${OPENCV_MODULE_opencv_core_BINARY_DIR}/version_string.inc" OUTPUT_QUIET)
 757     endif()
 758   endif()
 759
 760   if(UNIX)
 761     install(FILES "${OpenCV_SOURCE_DIR}/platforms/scripts/valgrind.supp"
 762                   "${OpenCV_SOURCE_DIR}/platforms/scripts/valgrind_3rdparty.supp"
 763             DESTINATION "${OPENCV_OTHER_INSTALL_PATH}" COMPONENT "dev")
 764   endif()
 765 endmacro()
 766
 767
 768 # Status report function.
 769 # Automatically align right column and selects text based on condition.
 770 # Usage:
 771 #   status(<text>)
 772 #   status(<heading> <value1> [<value2> ...])
 773 #   status(<heading> <condition> THEN <text for TRUE> ELSE <text for FALSE> )
 774 function(status text)
 775   set(status_cond)
 776   set(status_then)
 777   set(status_else)
 778
 779   set(status_current_name "cond")
 780   foreach(arg ${ARGN})
 781     if(arg STREQUAL "THEN")
 782       set(status_current_name "then")
 783     elseif(arg STREQUAL "ELSE")
 784       set(status_current_name "else")
 785     else()
 786       list(APPEND status_${status_current_name} ${arg})
 787     endif()
 788   endforeach()
 789
 790   if(DEFINED status_cond)
 791     set(status_placeholder_length 32)
 792     string(RANDOM LENGTH ${status_placeholder_length} ALPHABET " " status_placeholder)
 793     string(LENGTH "${text}" status_text_length)
 794     if(status_text_length LESS status_placeholder_length)
 795       string(SUBSTRING "${text}${status_placeholder}" 0 ${status_placeholder_length} status_text)
 796     elseif(DEFINED status_then OR DEFINED status_else)
 797       ocv_output_status("${text}")
 798       set(status_text "${status_placeholder}")
 799     else()
 800       set(status_text "${text}")
 801     endif()
 802
 803     if(DEFINED status_then OR DEFINED status_else)
 804       if(${status_cond})
 805         string(REPLACE ";" " " status_then "${status_then}")
 806         string(REGEX REPLACE "^[ \t]+" "" status_then "${status_then}")
 807         ocv_output_status("${status_text} ${status_then}")
 808       else()
 809         string(REPLACE ";" " " status_else "${status_else}")
 810         string(REGEX REPLACE "^[ \t]+" "" status_else "${status_else}")
 811         ocv_output_status("${status_text} ${status_else}")
 812       endif()
 813     else()
 814       string(REPLACE ";" " " status_cond "${status_cond}")
 815       string(REGEX REPLACE "^[ \t]+" "" status_cond "${status_cond}")
 816       ocv_output_status("${status_text} ${status_cond}")
 817     endif()
 818   else()
 819     ocv_output_status("${text}")
 820   endif()
 821 endfunction()
 822
 823 endif() # NOT DEFINED CMAKE_ARGC
 824
 825 #
 826 # Generate a list of enabled features basing on conditions:
 827 #   IF <cond> THEN <title>: check condition and append title to the result if it is true
 828 #   ELSE <title>: return provided value instead of empty result
 829 #   EXCLUSIVE: break after first successful condition
 830 #
 831 # Usage:
 832 #   ocv_build_features_string(out [EXCLUSIVE] [IF feature THEN title] ... [ELSE title])
 833 #
 834 function(ocv_build_features_string out)
 835   set(result)
 836   list(REMOVE_AT ARGV 0)
 837   foreach(arg ${ARGV})
 838     if(arg STREQUAL "EXCLUSIVE")
 839       set(exclusive TRUE)
 840     elseif(arg STREQUAL "IF")
 841       set(then FALSE)
 842       set(cond)
 843     elseif(arg STREQUAL "THEN")
 844       set(then TRUE)
 845       set(title)
 846     elseif(arg STREQUAL "ELSE")
 847       set(then FALSE)
 848       set(else TRUE)
 849     else()
 850       if(then)
 851         if(${cond})
 852           list(APPEND result "${arg}")
 853           if(exclusive)
 854             break()
 855           endif()
 856         endif()
 857       elseif(else)
 858         if(NOT result)
 859           set(result "${arg}")
 860         endif()
 861       else()
 862         list(APPEND cond ${arg})
 863       endif()
 864     endif()
 865   endforeach()
 866   set(${out} ${result} PARENT_SCOPE)
 867 endfunction()
 868
 869
 870 # remove all matching elements from the list
 871 macro(ocv_list_filterout lst regex)
 872   foreach(item ${${lst}})
 873     if(item MATCHES "${regex}")
 874       list(REMOVE_ITEM ${lst} "${item}")
 875     endif()
 876   endforeach()
 877 endmacro()
 878
 879 # filter matching elements from the list
 880 macro(ocv_list_filter lst regex)
 881   set(dst ${ARGN})
 882   if(NOT dst)
 883     set(dst ${lst})
 884   endif()
 885   set(__result ${${lst}})
 886   foreach(item ${__result})
 887     if(NOT item MATCHES "${regex}")
 888       list(REMOVE_ITEM __result "${item}")
 889     endif()
 890   endforeach()
 891   set(${dst} ${__result})
 892 endmacro()
 893
 894
 895 # stable & safe duplicates removal macro
 896 macro(ocv_list_unique __lst)
 897   if(${__lst})
 898     list(REMOVE_DUPLICATES ${__lst})
 899   endif()
 900 endmacro()
 901
 902
 903 # safe list reversal macro
 904 macro(ocv_list_reverse __lst)
 905   if(${__lst})
 906     list(REVERSE ${__lst})
 907   endif()
 908 endmacro()
 909
 910
 911 # safe list sorting macro
 912 macro(ocv_list_sort __lst)
 913   if(${__lst})
 914     list(SORT ${__lst})
 915   endif()
 916 endmacro()
 917
 918
 919 # add prefix to each item in the list
 920 macro(ocv_list_add_prefix LST PREFIX)
 921   set(__tmp "")
 922   foreach(item ${${LST}})
 923     list(APPEND __tmp "${PREFIX}${item}")
 924   endforeach()
 925   set(${LST} ${__tmp})
 926   unset(__tmp)
 927 endmacro()
 928
 929
 930 # add suffix to each item in the list
 931 macro(ocv_list_add_suffix LST SUFFIX)
 932   set(__tmp "")
 933   foreach(item ${${LST}})
 934     list(APPEND __tmp "${item}${SUFFIX}")
 935   endforeach()
 936   set(${LST} ${__tmp})
 937   unset(__tmp)
 938 endmacro()
 939
 940
 941 # gets and removes the first element from the list
 942 macro(ocv_list_pop_front LST VAR)
 943   if(${LST})
 944     list(GET ${LST} 0 ${VAR})
 945     list(REMOVE_AT ${LST} 0)
 946   else()
 947     set(${VAR} "")
 948   endif()
 949 endmacro()
 950
 951 # Get list of duplicates in the list of input items.
 952 # ocv_get_duplicates(<output list> <element> [<element> ...])
 953 function(ocv_get_duplicates res)
 954   if(ARGC LESS 2)
 955     message(FATAL_ERROR "Invalid call to ocv_get_duplicates")
 956   endif()
 957   set(lst ${ARGN})
 958   list(SORT lst)
 959   set(prev_item)
 960   foreach(item ${lst})
 961     if(item STREQUAL prev_item)
 962       list(APPEND dups ${item})
 963     endif()
 964     set(prev_item ${item})
 965   endforeach()
 966   set(${res} ${dups} PARENT_SCOPE)
 967 endfunction()
 968
 969 # simple regex escaping routine (does not cover all cases!!!)
 970 macro(ocv_regex_escape var regex)
 971   string(REGEX REPLACE "([+.*^$])" "\\\\1" ${var} "${regex}")
 972 endmacro()
 973
 974
 975 # convert list of paths to full paths
 976 macro(ocv_convert_to_full_paths VAR)
 977   if(${VAR})
 978     set(__tmp "")
 979     foreach(path ${${VAR}})
 980       get_filename_component(${VAR} "${path}" ABSOLUTE)
 981       list(APPEND __tmp "${${VAR}}")
 982     endforeach()
 983     set(${VAR} ${__tmp})
 984     unset(__tmp)
 985   endif()
 986 endmacro()
 987
 988
 989 # convert list of paths to libraries names without lib prefix
 990 function(ocv_convert_to_lib_name var)
 991   set(tmp "")
 992   foreach(path ${ARGN})
 993     get_filename_component(tmp_name "${path}" NAME)
 994     ocv_get_libname(tmp_name "${tmp_name}")
 995     list(APPEND tmp "${tmp_name}")
 996   endforeach()
 997   set(${var} ${tmp} PARENT_SCOPE)
 998 endfunction()
 999
1000
1001 # add install command
1002 function(ocv_install_target)
1003   if(APPLE_FRAMEWORK AND BUILD_SHARED_LIBS)
1004     install(TARGETS ${ARGN} FRAMEWORK DESTINATION ${OPENCV_3P_LIB_INSTALL_PATH})
1005   else()
1006     install(TARGETS ${ARGN})
1007   endif()
1008
1009   set(isPackage 0)
1010   unset(__package)
1011   unset(__target)
1012   foreach(e ${ARGN})
1013     if(NOT DEFINED __target)
1014       set(__target "${e}")
1015     endif()
1016     if(isPackage EQUAL 1)
1017       set(__package "${e}")
1018       break()
1019     endif()
1020     if(e STREQUAL "EXPORT")
1021       set(isPackage 1)
1022     endif()
1023   endforeach()
1024
1025   if(DEFINED __package)
1026     list(APPEND ${__package}_TARGETS ${__target})
1027     set(${__package}_TARGETS "${${__package}_TARGETS}" CACHE INTERNAL "List of ${__package} targets")
1028   endif()
1029
1030   if(MSVC)
1031     if(INSTALL_PDB AND (NOT INSTALL_IGNORE_PDB))
1032       set(__target "${ARGV0}")
1033
1034       set(__location_key "ARCHIVE")  # static libs
1035       get_target_property(__target_type ${__target} TYPE)
1036       if("${__target_type}" STREQUAL "SHARED_LIBRARY")
1037         set(__location_key "RUNTIME")  # shared libs (.DLL)
1038       endif()
1039
1040       set(processDst 0)
1041       set(isDst 0)
1042       unset(__dst)
1043       foreach(e ${ARGN})
1044         if(isDst EQUAL 1)
1045           set(__dst "${e}")
1046           break()
1047         endif()
1048         if(processDst EQUAL 1 AND e STREQUAL "DESTINATION")
1049           set(isDst 1)
1050         endif()
1051         if(e STREQUAL "${__location_key}")
1052           set(processDst 1)
1053         else()
1054           set(processDst 0)
1055         endif()
1056       endforeach()
1057
1058 #      message(STATUS "Process ${__target} dst=${__dst}...")
1059       if(DEFINED __dst)
1060         if(NOT CMAKE_VERSION VERSION_LESS 3.1.0)
1061           set(__pdb_install_component "pdb")
1062           if(DEFINED INSTALL_PDB_COMPONENT AND INSTALL_PDB_COMPONENT)
1063             set(__pdb_install_component "${INSTALL_PDB_COMPONENT}")
1064           endif()
1065 #          message(STATUS "Adding PDB file installation rule: target=${__target} dst=${__dst} component=${__pdb_install_component}")
1066           if("${__target_type}" STREQUAL "SHARED_LIBRARY")
1067             install(FILES "$<TARGET_PDB_FILE:${__target}>" DESTINATION "${__dst}" COMPONENT ${__pdb_install_component} OPTIONAL)
1068           else()
1069             # There is no generator expression similar to TARGET_PDB_FILE and TARGET_PDB_FILE can't be used: https://gitlab.kitware.com/cmake/cmake/issues/16932
1070             # However we still want .pdb files like: 'lib/Debug/opencv_core341d.pdb' or '3rdparty/lib/zlibd.pdb'
1071             install(FILES "$<TARGET_PROPERTY:${__target},ARCHIVE_OUTPUT_DIRECTORY>/$<CONFIG>/$<IF:$<BOOL:$<TARGET_PROPERTY:${__target},COMPILE_PDB_NAME_DEBUG>>,$<TARGET_PROPERTY:${__target},COMPILE_PDB_NAME_DEBUG>,$<TARGET_PROPERTY:${__target},COMPILE_PDB_NAME>>.pdb"
1072                 DESTINATION "${__dst}" CONFIGURATIONS Debug COMPONENT ${__pdb_install_component} OPTIONAL)
1073             install(FILES "$<TARGET_PROPERTY:${__target},ARCHIVE_OUTPUT_DIRECTORY>/$<CONFIG>/$<IF:$<BOOL:$<TARGET_PROPERTY:${__target},COMPILE_PDB_NAME_RELEASE>>,$<TARGET_PROPERTY:${__target},COMPILE_PDB_NAME_RELEASE>,$<TARGET_PROPERTY:${__target},COMPILE_PDB_NAME>>.pdb"
1074                 DESTINATION "${__dst}" CONFIGURATIONS Release COMPONENT ${__pdb_install_component} OPTIONAL)
1075           endif()
1076         else()
1077           message(WARNING "PDB files installation is not supported (need CMake >= 3.1.0)")
1078         endif()
1079       endif()
1080     endif()
1081   endif()
1082 endfunction()
1083
1084 # ocv_install_3rdparty_licenses(<library-name> <filename1> [<filename2> ..])
1085 function(ocv_install_3rdparty_licenses library)
1086   foreach(filename ${ARGN})
1087     get_filename_component(name "${filename}" NAME)
1088     install(
1089       FILES "${filename}"
1090       DESTINATION "${OPENCV_OTHER_INSTALL_PATH}/licenses"
1091       COMPONENT licenses
1092       RENAME "${library}-${name}"
1093       OPTIONAL)
1094   endforeach()
1095 endfunction()
1096
1097 # read set of version defines from the header file
1098 macro(ocv_parse_header FILENAME FILE_VAR)
1099   set(vars_regex "")
1100   set(__parnet_scope OFF)
1101   set(__add_cache OFF)
1102   foreach(name ${ARGN})
1103     if(${name} STREQUAL "PARENT_SCOPE")
1104       set(__parnet_scope ON)
1105     elseif(${name} STREQUAL "CACHE")
1106       set(__add_cache ON)
1107     elseif(vars_regex)
1108       set(vars_regex "${vars_regex}|${name}")
1109     else()
1110       set(vars_regex "${name}")
1111     endif()
1112   endforeach()
1113   if(EXISTS "${FILENAME}")
1114     file(STRINGS "${FILENAME}" ${FILE_VAR} REGEX "#define[ \t]+(${vars_regex})[ \t]+[0-9]+" )
1115   else()
1116     unset(${FILE_VAR})
1117   endif()
1118   foreach(name ${ARGN})
1119     if(NOT ${name} STREQUAL "PARENT_SCOPE" AND NOT ${name} STREQUAL "CACHE")
1120       if(${FILE_VAR})
1121         if(${FILE_VAR} MATCHES ".+[ \t]${name}[ \t]+([0-9]+).*")
1122           string(REGEX REPLACE ".+[ \t]${name}[ \t]+([0-9]+).*" "\\1" ${name} "${${FILE_VAR}}")
1123         else()
1124           set(${name} "")
1125         endif()
1126         if(__add_cache)
1127           set(${name} ${${name}} CACHE INTERNAL "${name} parsed from ${FILENAME}" FORCE)
1128         elseif(__parnet_scope)
1129           set(${name} "${${name}}" PARENT_SCOPE)
1130         endif()
1131       else()
1132         unset(${name} CACHE)
1133       endif()
1134     endif()
1135   endforeach()
1136 endmacro()
1137
1138 # read single version define from the header file
1139 macro(ocv_parse_header2 LIBNAME HDR_PATH VARNAME)
1140   ocv_clear_vars(${LIBNAME}_VERSION_MAJOR
1141                  ${LIBNAME}_VERSION_MAJOR
1142                  ${LIBNAME}_VERSION_MINOR
1143                  ${LIBNAME}_VERSION_PATCH
1144                  ${LIBNAME}_VERSION_TWEAK
1145                  ${LIBNAME}_VERSION_STRING)
1146   set(${LIBNAME}_H "")
1147   if(EXISTS "${HDR_PATH}")
1148     file(STRINGS "${HDR_PATH}" ${LIBNAME}_H REGEX "^#define[ \t]+${VARNAME}[ \t]+\"[^\"]*\".*$" LIMIT_COUNT 1)
1149   endif()
1150
1151   if(${LIBNAME}_H)
1152     string(REGEX REPLACE "^.*[ \t]${VARNAME}[ \t]+\"([0-9]+).*$" "\\1" ${LIBNAME}_VERSION_MAJOR "${${LIBNAME}_H}")
1153     string(REGEX REPLACE "^.*[ \t]${VARNAME}[ \t]+\"[0-9]+\\.([0-9]+).*$" "\\1" ${LIBNAME}_VERSION_MINOR  "${${LIBNAME}_H}")
1154     string(REGEX REPLACE "^.*[ \t]${VARNAME}[ \t]+\"[0-9]+\\.[0-9]+\\.([0-9]+).*$" "\\1" ${LIBNAME}_VERSION_PATCH "${${LIBNAME}_H}")
1155     set(${LIBNAME}_VERSION_MAJOR ${${LIBNAME}_VERSION_MAJOR} ${ARGN})
1156     set(${LIBNAME}_VERSION_MINOR ${${LIBNAME}_VERSION_MINOR} ${ARGN})
1157     set(${LIBNAME}_VERSION_PATCH ${${LIBNAME}_VERSION_PATCH} ${ARGN})
1158     set(${LIBNAME}_VERSION_STRING "${${LIBNAME}_VERSION_MAJOR}.${${LIBNAME}_VERSION_MINOR}.${${LIBNAME}_VERSION_PATCH}")
1159
1160     # append a TWEAK version if it exists:
1161     set(${LIBNAME}_VERSION_TWEAK "")
1162     if("${${LIBNAME}_H}" MATCHES "^.*[ \t]${VARNAME}[ \t]+\"[0-9]+\\.[0-9]+\\.[0-9]+\\.([0-9]+).*$")
1163       set(${LIBNAME}_VERSION_TWEAK "${CMAKE_MATCH_1}" ${ARGN})
1164     endif()
1165     if(${LIBNAME}_VERSION_TWEAK)
1166       set(${LIBNAME}_VERSION_STRING "${${LIBNAME}_VERSION_STRING}.${${LIBNAME}_VERSION_TWEAK}" ${ARGN})
1167     else()
1168       set(${LIBNAME}_VERSION_STRING "${${LIBNAME}_VERSION_STRING}" ${ARGN})
1169     endif()
1170   endif()
1171 endmacro()
1172
1173 # read single version info from the pkg file
1174 macro(ocv_parse_pkg LIBNAME PKG_PATH SCOPE)
1175   if(EXISTS "${PKG_PATH}/${LIBNAME}.pc")
1176     file(STRINGS "${PKG_PATH}/${LIBNAME}.pc" line_to_parse REGEX "^Version:[ \t]+[0-9.]*.*$" LIMIT_COUNT 1)
1177     STRING(REGEX REPLACE ".*Version: ([^ ]+).*" "\\1" ALIASOF_${LIBNAME}_VERSION "${line_to_parse}" )
1178   endif()
1179 endmacro()
1180
1181 ################################################################################################
1182 # short command to setup source group
1183 function(ocv_source_group group)
1184   if(BUILD_opencv_world AND OPENCV_MODULE_${the_module}_IS_PART_OF_WORLD)
1185     set(group "${the_module}\\${group}")
1186   endif()
1187   cmake_parse_arguments(SG "" "DIRBASE" "GLOB;GLOB_RECURSE;FILES" ${ARGN})
1188   set(files "")
1189   if(SG_FILES)
1190     list(APPEND files ${SG_FILES})
1191   endif()
1192   if(SG_GLOB)
1193     file(GLOB srcs ${SG_GLOB})
1194     list(APPEND files ${srcs})
1195   endif()
1196   if(SG_GLOB_RECURSE)
1197     file(GLOB_RECURSE srcs ${SG_GLOB_RECURSE})
1198     list(APPEND files ${srcs})
1199   endif()
1200   if(SG_DIRBASE)
1201     foreach(f ${files})
1202       file(RELATIVE_PATH fpart "${SG_DIRBASE}" "${f}")
1203       if(fpart MATCHES "^\\.\\.")
1204         message(AUTHOR_WARNING "Can't detect subpath for source_group command: Group=${group} FILE=${f} DIRBASE=${SG_DIRBASE}")
1205         set(fpart "")
1206       else()
1207         get_filename_component(fpart "${fpart}" PATH)
1208         if(fpart)
1209           set(fpart "/${fpart}") # add '/'
1210           string(REPLACE "/" "\\" fpart "${fpart}")
1211         endif()
1212       endif()
1213       source_group("${group}${fpart}" FILES ${f})
1214     endforeach()
1215   else()
1216     source_group(${group} FILES ${files})
1217   endif()
1218 endfunction()
1219
1220 macro(__ocv_push_target_link_libraries)
1221   if(NOT TARGET ${target})
1222     if(NOT DEFINED OPENCV_MODULE_${target}_LOCATION)
1223       message(FATAL_ERROR "ocv_target_link_libraries: invalid target: '${target}'")
1224     endif()
1225     set(OPENCV_MODULE_${target}_LINK_DEPS ${OPENCV_MODULE_${target}_LINK_DEPS} ${ARGN} CACHE INTERNAL "" FORCE)
1226   else()
1227     target_link_libraries(${target} ${ARGN})
1228   endif()
1229 endmacro()
1230
1231 function(ocv_target_link_libraries target)
1232   set(LINK_DEPS ${ARGN})
1233   _ocv_fix_target(target)
1234   set(LINK_MODE "LINK_PRIVATE")
1235   set(LINK_PENDING "")
1236   foreach(dep ${LINK_DEPS})
1237     if(" ${dep}" STREQUAL " ${target}")
1238       # prevent "link to itself" warning (world problem)
1239     elseif(" ${dep}" STREQUAL " LINK_PRIVATE" OR " ${dep}" STREQUAL "LINK_PUBLIC")
1240       if(NOT LINK_PENDING STREQUAL "")
1241         __ocv_push_target_link_libraries(${LINK_MODE} ${LINK_PENDING})
1242         set(LINK_PENDING "")
1243         set(LINK_MODE "${dep}")
1244       endif()
1245     else()
1246       if(BUILD_opencv_world)
1247         if(OPENCV_MODULE_${dep}_IS_PART_OF_WORLD)
1248           set(dep opencv_world)
1249         endif()
1250       endif()
1251       list(APPEND LINK_PENDING "${dep}")
1252     endif()
1253   endforeach()
1254   if(NOT LINK_PENDING STREQUAL "")
1255     __ocv_push_target_link_libraries(${LINK_MODE} ${LINK_PENDING})
1256   endif()
1257 endfunction()
1258
1259 function(ocv_target_compile_definitions target)
1260   _ocv_fix_target(target)
1261   if(NOT TARGET ${target})
1262     if(NOT DEFINED OPENCV_MODULE_${target}_LOCATION)
1263       message(FATAL_ERROR "ocv_target_compile_definitions: invalid target: '${target}'")
1264     endif()
1265     set(OPENCV_MODULE_${target}_COMPILE_DEFINITIONS ${OPENCV_MODULE_${target}_COMPILE_DEFINITIONS} ${ARGN} CACHE INTERNAL "" FORCE)
1266   else()
1267     target_compile_definitions(${target} ${ARGN})
1268   endif()
1269 endfunction()
1270
1271
1272 function(_ocv_append_target_includes target)
1273   if(DEFINED OCV_TARGET_INCLUDE_DIRS_${target})
1274     target_include_directories(${target} PRIVATE ${OCV_TARGET_INCLUDE_DIRS_${target}})
1275     if(OPENCV_DEPENDANT_TARGETS_${target})
1276       foreach(t ${OPENCV_DEPENDANT_TARGETS_${target}})
1277         target_include_directories(${t} PRIVATE ${OCV_TARGET_INCLUDE_DIRS_${target}})
1278       endforeach()
1279     endif()
1280     unset(OCV_TARGET_INCLUDE_DIRS_${target} CACHE)
1281   endif()
1282
1283   if(DEFINED OCV_TARGET_INCLUDE_SYSTEM_DIRS_${target})
1284     target_include_directories(${target} SYSTEM PRIVATE ${OCV_TARGET_INCLUDE_SYSTEM_DIRS_${target}})
1285     if(OPENCV_DEPENDANT_TARGETS_${target})
1286       foreach(t ${OPENCV_DEPENDANT_TARGETS_${target}})
1287         target_include_directories(${t} SYSTEM PRIVATE ${OCV_TARGET_INCLUDE_SYSTEM_DIRS_${target}})
1288       endforeach()
1289     endif()
1290     unset(OCV_TARGET_INCLUDE_SYSTEM_DIRS_${target} CACHE)
1291   endif()
1292 endfunction()
1293
1294 function(ocv_add_executable target)
1295   add_executable(${target} ${ARGN})
1296   _ocv_append_target_includes(${target})
1297 endfunction()
1298
1299 function(ocv_add_library target)
1300   if(HAVE_CUDA AND ARGN MATCHES "\\.cu")
1301     ocv_include_directories(${CUDA_INCLUDE_DIRS})
1302     ocv_cuda_compile(cuda_objs ${ARGN})
1303     set(OPENCV_MODULE_${target}_CUDA_OBJECTS ${cuda_objs} CACHE INTERNAL "Compiled CUDA object files")
1304   endif()
1305
1306   add_library(${target} ${ARGN} ${cuda_objs})
1307
1308   if(APPLE_FRAMEWORK AND BUILD_SHARED_LIBS)
1309     message(STATUS "Setting Apple target properties for ${target}")
1310
1311     set(CMAKE_SHARED_LIBRARY_RUNTIME_C_FLAG 1)
1312
1313     set_target_properties(${target} PROPERTIES
1314       FRAMEWORK TRUE
1315       MACOSX_FRAMEWORK_IDENTIFIER org.opencv
1316       MACOSX_FRAMEWORK_INFO_PLIST ${CMAKE_BINARY_DIR}/ios/Info.plist
1317       # "current version" in semantic format in Mach-O binary file
1318       VERSION ${OPENCV_LIBVERSION}
1319       # "compatibility version" in semantic format in Mach-O binary file
1320       SOVERSION ${OPENCV_LIBVERSION}
1321       INSTALL_RPATH ""
1322       INSTALL_NAME_DIR "@rpath"
1323       BUILD_WITH_INSTALL_RPATH 1
1324       LIBRARY_OUTPUT_NAME "opencv2"
1325       XCODE_ATTRIBUTE_TARGETED_DEVICE_FAMILY "1,2"
1326       #PUBLIC_HEADER "${OPENCV_CONFIG_FILE_INCLUDE_DIR}/cvconfig.h"
1327       #XCODE_ATTRIBUTE_CODE_SIGN_IDENTITY "iPhone Developer"
1328     )
1329   endif()
1330
1331   _ocv_append_target_includes(${target})
1332 endfunction()
1333
1334
1335 macro(ocv_get_libname var_name)
1336   get_filename_component(__libname "${ARGN}" NAME)
1337   # libopencv_core.so.3.3 -> opencv_core
1338   string(REGEX REPLACE "^lib(.+)\\.(a|so|dll)(\\.[.0-9]+)?$" "\\1" __libname "${__libname}")
1339   # MacOSX: libopencv_core.3.3.1.dylib -> opencv_core
1340   string(REGEX REPLACE "^lib(.+[^.0-9])\\.([.0-9]+\\.)?dylib$" "\\1" __libname "${__libname}")
1341   set(${var_name} "${__libname}")
1342 endmacro()
1343
1344 # build the list of opencv libs and dependencies for all modules
1345 #  _modules - variable to hold list of all modules
1346 #  _extra - variable to hold list of extra dependencies
1347 #  _3rdparty - variable to hold list of prebuilt 3rdparty libraries
1348 macro(ocv_get_all_libs _modules _extra _3rdparty)
1349   set(${_modules} "")
1350   set(${_extra} "")
1351   set(${_3rdparty} "")
1352   foreach(m ${OPENCV_MODULES_PUBLIC})
1353     if(TARGET ${m})
1354       get_target_property(deps ${m} INTERFACE_LINK_LIBRARIES)
1355       if(NOT deps)
1356         set(deps "")
1357       endif()
1358     else()
1359       set(deps "")
1360     endif()
1361     set(_rev_deps "${deps};${m}")
1362     ocv_list_reverse(_rev_deps)
1363     foreach (dep ${_rev_deps})
1364       if(DEFINED OPENCV_MODULE_${dep}_LOCATION)
1365         list(INSERT ${_modules} 0 ${dep})
1366       endif()
1367     endforeach()
1368     foreach (dep ${deps} ${OPENCV_LINKER_LIBS})
1369       if (NOT DEFINED OPENCV_MODULE_${dep}_LOCATION)
1370         if(dep MATCHES "^\\$<LINK_ONLY:([^>]+)>$")
1371           set(dep "${CMAKE_MATCH_1}")
1372         endif()
1373         if(dep MATCHES "^\\$<")
1374           message(WARNING "Unexpected CMake generator expression: ${dep}")
1375         endif()
1376         if (TARGET ${dep})
1377           get_target_property(_type ${dep} TYPE)
1378           if(_type STREQUAL "STATIC_LIBRARY" AND BUILD_SHARED_LIBS OR _type STREQUAL "INTERFACE_LIBRARY")
1379             # nothing
1380           else()
1381             get_target_property(_output ${dep} IMPORTED_LOCATION)
1382             if(NOT _output)
1383               get_target_property(_output ${dep} ARCHIVE_OUTPUT_DIRECTORY)
1384               get_target_property(_output_name ${dep} OUTPUT_NAME)
1385               if(NOT _output_name)
1386                 set(_output_name "${dep}")
1387               endif()
1388             else()
1389               get_filename_component(_output_name "${_output}" NAME)
1390             endif()
1391             string(FIND "${_output}" "${CMAKE_BINARY_DIR}" _POS)
1392             if (_POS EQUAL 0)
1393               ocv_get_libname(_libname "${_output_name}")
1394               list(INSERT ${_3rdparty} 0 ${dep})
1395             else()
1396               if(_output)
1397                 list(INSERT ${_extra} 0 ${_output})
1398               else()
1399                 list(INSERT ${_extra} 0 ${dep})
1400               endif()
1401             endif()
1402           endif()
1403         else()
1404           list(INSERT ${_extra} 0 ${dep})
1405         endif()
1406       endif()
1407     endforeach()
1408   endforeach()
1409
1410   ocv_list_filterout(${_modules} "^[\$]<")
1411   ocv_list_filterout(${_3rdparty} "^[\$]<")
1412   ocv_list_filterout(${_extra} "^[\$]<")
1413
1414   # convert CMake lists to makefile literals
1415   foreach(lst ${_modules} ${_3rdparty} ${_extra})
1416     ocv_list_unique(${lst})
1417     ocv_list_reverse(${lst})
1418   endforeach()
1419 endmacro()
1420
1421
1422 function(ocv_add_test_from_target test_name test_kind the_target)
1423   if(CMAKE_VERSION VERSION_GREATER "2.8" AND NOT CMAKE_CROSSCOMPILING)
1424     if(NOT "${test_kind}" MATCHES "^(Accuracy|Performance|Sanity)$")
1425       message(FATAL_ERROR "Unknown test kind : ${test_kind}")
1426     endif()
1427     if(NOT TARGET "${the_target}")
1428       message(FATAL_ERROR "${the_target} is not a CMake target")
1429     endif()
1430
1431     string(TOLOWER "${test_kind}" test_kind_lower)
1432     set(test_report_dir "${CMAKE_BINARY_DIR}/test-reports/${test_kind_lower}")
1433     file(MAKE_DIRECTORY "${test_report_dir}")
1434
1435     add_test(NAME "${test_name}"
1436       COMMAND "${the_target}"
1437               "--gtest_output=xml:${the_target}.xml"
1438               ${ARGN})
1439
1440     set_tests_properties("${test_name}" PROPERTIES
1441       LABELS "${OPENCV_MODULE_${the_module}_LABEL};${test_kind}"
1442       WORKING_DIRECTORY "${test_report_dir}")
1443
1444     if(OPENCV_TEST_DATA_PATH)
1445       set_tests_properties("${test_name}" PROPERTIES
1446         ENVIRONMENT "OPENCV_TEST_DATA_PATH=${OPENCV_TEST_DATA_PATH}")
1447     endif()
1448   endif()
1449 endfunction()
1450
1451 macro(ocv_add_testdata basedir dest_subdir)
1452   if(BUILD_TESTS)
1453     if(NOT CMAKE_CROSSCOMPILING AND NOT INSTALL_TESTS)
1454       file(COPY ${basedir}/
1455            DESTINATION ${CMAKE_BINARY_DIR}/${OPENCV_TEST_DATA_INSTALL_PATH}/${dest_subdir}
1456            ${ARGN}
1457       )
1458     endif()
1459     if(INSTALL_TESTS)
1460       install(DIRECTORY ${basedir}/
1461               DESTINATION ${OPENCV_TEST_DATA_INSTALL_PATH}/${dest_subdir}
1462               COMPONENT "tests"
1463               ${ARGN}
1464       )
1465     endif()
1466   endif()
1467 endmacro()
1468
1469 macro(ocv_generate_vs_version_file DESTINATION)
1470   cmake_parse_arguments(VS_VER "" "NAME;FILEDESCRIPTION;FILEVERSION;INTERNALNAME;COPYRIGHT;ORIGINALFILENAME;PRODUCTNAME;PRODUCTVERSION;COMMENTS;FILEVERSION_QUAD;PRODUCTVERSION_QUAD" "" ${ARGN})
1471
1472   macro(__vs_ver_update_variable name)
1473     if(VS_VER_NAME AND DEFINED OPENCV_${VS_VER_NAME}_VS_VER_${name})
1474       set(OPENCV_VS_VER_${name} "${OPENCV_${VS_VER_NAME}_VS_VER_${name}}")
1475     elseif(VS_VER_${name})
1476       set(OPENCV_VS_VER_${name} "${VS_VER_${name}}")
1477     endif()
1478   endmacro()
1479
1480   __vs_ver_update_variable(FILEVERSION_QUAD)
1481   __vs_ver_update_variable(PRODUCTVERSION_QUAD)
1482
1483   macro(__vs_ver_update_str_variable name)
1484     if(VS_VER_NAME AND DEFINED OPENCV_${VS_VER_NAME}_VS_VER_${name})
1485       set(OPENCV_VS_VER_${name}_STR "${OPENCV_${VS_VER_NAME}_VS_VER_${name}}")
1486     elseif(VS_VER_${name})
1487       set(OPENCV_VS_VER_${name}_STR "${VS_VER_${name}}")
1488     endif()
1489   endmacro()
1490
1491   __vs_ver_update_str_variable(FILEDESCRIPTION)
1492   __vs_ver_update_str_variable(FILEVERSION)
1493   __vs_ver_update_str_variable(INTERNALNAME)
1494   __vs_ver_update_str_variable(COPYRIGHT)
1495   __vs_ver_update_str_variable(ORIGINALFILENAME)
1496   __vs_ver_update_str_variable(PRODUCTNAME)
1497   __vs_ver_update_str_variable(PRODUCTVERSION)
1498   __vs_ver_update_str_variable(COMMENTS)
1499
1500   if(OPENCV_VS_VER_COPYRIGHT_STR)
1501     set(OPENCV_VS_VER_HAVE_COPYRIGHT_STR 1)
1502   else()
1503     set(OPENCV_VS_VER_HAVE_COPYRIGHT_STR 0)
1504   endif()
1505
1506   if(OPENCV_VS_VER_COMMENTS_STR)
1507     set(OPENCV_VS_VER_HAVE_COMMENTS_STR 1)
1508   else()
1509     set(OPENCV_VS_VER_HAVE_COMMENTS_STR 0)
1510   endif()
1511
1512   configure_file("${OpenCV_SOURCE_DIR}/cmake/templates/vs_version.rc.in" "${DESTINATION}" @ONLY)
1513 endmacro()
1514
1515 macro(ocv_cmake_script_append_var content_var)
1516   foreach(var_name ${ARGN})
1517     set(${content_var} "${${content_var}}
1518 set(${var_name} \"${${var_name}}\")
1519 ")
1520   endforeach()
1521 endmacro()
1522
1523 macro(ocv_copyfiles_append_file list_var src dst)
1524   list(LENGTH ${list_var} __id)
1525   list(APPEND ${list_var} ${__id})
1526   set(${list_var}_SRC_${__id} "${src}")
1527   set(${list_var}_DST_${__id} "${dst}")
1528 endmacro()
1529
1530 macro(ocv_copyfiles_append_dir list_var src dst)
1531   set(__glob ${ARGN})
1532   list(LENGTH ${list_var} __id)
1533   list(APPEND ${list_var} ${__id})
1534   set(${list_var}_SRC_${__id} "${src}")
1535   set(${list_var}_DST_${__id} "${dst}")
1536   set(${list_var}_MODE_${__id} "COPYDIR")
1537   if(__glob)
1538     set(${list_var}_GLOB_${__id} ${__glob})
1539   endif()
1540 endmacro()
1541
1542 macro(ocv_copyfiles_make_config_string content_var list_var)
1543   set(var_name "${list_var}")
1544   set(${content_var} "${${content_var}}
1545 set(${var_name} \"${${var_name}}\")
1546 ")
1547   foreach(__id ${${list_var}})
1548     set(${content_var} "${${content_var}}
1549 set(${list_var}_SRC_${__id} \"${${list_var}_SRC_${__id}}\")
1550 set(${list_var}_DST_${__id} \"${${list_var}_DST_${__id}}\")
1551 ")
1552     if(DEFINED ${list_var}_MODE_${__id})
1553       set(${content_var} "${${content_var}}set(${list_var}_MODE_${__id} \"${${list_var}_MODE_${__id}}\")\n")
1554     endif()
1555     if(DEFINED ${list_var}_GLOB_${__id})
1556       set(${content_var} "${${content_var}}set(${list_var}_GLOB_${__id} \"${${list_var}_GLOB_${__id}}\")\n")
1557     endif()
1558   endforeach()
1559 endmacro()
1560
1561 macro(ocv_copyfiles_make_config_file filename_var list_var)
1562   ocv_copyfiles_make_config_string(${list_var}_CONFIG ${list_var})
1563   set(${filename_var} "${CMAKE_CURRENT_BINARY_DIR}/copyfiles-${list_var}.cmake")
1564   file(WRITE "${${filename_var}}" "${${list_var}_CONFIG}")
1565 endmacro()
1566
1567 macro(ocv_copyfiles_add_forced_target target list_var comment_str)
1568   ocv_copyfiles_make_config_file(CONFIG_FILE ${list_var})
1569   ocv_cmake_byproducts(__byproducts BYPRODUCTS "${OPENCV_DEPHELPER}/${target}")
1570   add_custom_target(${target}
1571       ${__byproducts}  # required for add_custom_target() by ninja
1572       COMMAND ${CMAKE_COMMAND}
1573         "-DCONFIG_FILE:PATH=${CONFIG_FILE}"
1574         "-DCOPYLIST_VAR:STRING=${list_var}"
1575         "-DDEPHELPER=${OPENCV_DEPHELPER}/${target}"
1576         -P "${OpenCV_SOURCE_DIR}/cmake/copy_files.cmake"
1577       WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
1578       COMMENT "${comment_str}"
1579       DEPENDS "${OpenCV_SOURCE_DIR}/cmake/copy_files.cmake"
1580               # ninja warn about file(WRITE): "${SRC_COPY_CONFIG_FILE}"
1581   )
1582 endmacro()
1583
1584 macro(ocv_copyfiles_add_target target list_var comment_str)
1585   set(deps ${ARGN})
1586   ocv_copyfiles_make_config_file(CONFIG_FILE ${list_var})
1587   add_custom_command(OUTPUT "${OPENCV_DEPHELPER}/${target}"
1588       COMMAND ${CMAKE_COMMAND}
1589         "-DCONFIG_FILE:PATH=${CONFIG_FILE}"
1590         "-DCOPYLIST_VAR:STRING=${list_var}"
1591         "-DDEPHELPER=${OPENCV_DEPHELPER}/${target}"
1592         -P "${OpenCV_SOURCE_DIR}/cmake/copy_files.cmake"
1593       WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
1594       COMMENT "${comment_str}"
1595       DEPENDS "${OpenCV_SOURCE_DIR}/cmake/copy_files.cmake" ${deps}
1596               # ninja warn about file(WRITE): "${SRC_COPY_CONFIG_FILE}"
1597   )
1598   add_custom_target(${target} DEPENDS "${OPENCV_DEPHELPER}/${target}")
1599 endmacro()
1600
1601 macro(ocv_get_smart_file_name output_var fpath)
1602   ocv_is_subdir(__subir "${OpenCV_BINARY_DIR}" "${fpath}")
1603   if(__subir)
1604     file(RELATIVE_PATH ${output_var} "${OpenCV_BINARY_DIR}" "${fpath}")
1605     set(${output_var} "<BUILD>/${${output_var}}")
1606   else()
1607     ocv_is_subdir(__subir "${OpenCV_SOURCE_DIR}" "${fpath}")
1608     if(__subir)
1609       file(RELATIVE_PATH ${output_var} "${OpenCV_SOURCE_DIR}" "${fpath}")
1610     else()
1611       set(${output_var} "${fpath}")
1612     endif()
1613   endif()
1614   unset(__subir)
1615 endmacro()
1616
1617 # Needed by install(DIRECTORY ...)
1618 if(NOT CMAKE_VERSION VERSION_LESS 3.1)
1619   set(compatible_MESSAGE_NEVER MESSAGE_NEVER)
1620 else()
1621   set(compatible_MESSAGE_NEVER "")
1622 endif()
1623
1624
1625 macro(ocv_git_describe var_name path)
1626   if(GIT_FOUND)
1627     execute_process(COMMAND "${GIT_EXECUTABLE}" describe --tags --exact-match --dirty
1628       WORKING_DIRECTORY "${path}"
1629       OUTPUT_VARIABLE ${var_name}
1630       RESULT_VARIABLE GIT_RESULT
1631       ERROR_QUIET
1632       OUTPUT_STRIP_TRAILING_WHITESPACE
1633     )
1634     if(NOT GIT_RESULT EQUAL 0)
1635       execute_process(COMMAND "${GIT_EXECUTABLE}" describe --tags --always --dirty --match "[0-9].[0-9].[0-9]*" --exclude "[^-]*-cvsdk"
1636         WORKING_DIRECTORY "${path}"
1637         OUTPUT_VARIABLE ${var_name}
1638         RESULT_VARIABLE GIT_RESULT
1639         ERROR_QUIET
1640         OUTPUT_STRIP_TRAILING_WHITESPACE
1641       )
1642       if(NOT GIT_RESULT EQUAL 0)  # --exclude is not supported by 'git'
1643         # match only tags with complete OpenCV versions (ignores -alpha/-beta/-rc suffixes)
1644         execute_process(COMMAND "${GIT_EXECUTABLE}" describe --tags --always --dirty --match "[0-9].[0-9]*[0-9]"
1645           WORKING_DIRECTORY "${path}"
1646           OUTPUT_VARIABLE ${var_name}
1647           RESULT_VARIABLE GIT_RESULT
1648           ERROR_QUIET
1649           OUTPUT_STRIP_TRAILING_WHITESPACE
1650         )
1651         if(NOT GIT_RESULT EQUAL 0)
1652           set(${var_name} "unknown")
1653         endif()
1654       endif()
1655     endif()
1656   else()
1657     set(${var_name} "unknown")
1658   endif()
1659 endmacro()