Merge pull request #3103 from vpisarev:core_imgproc_optim_rearrangements
[profile/ivi/opencv.git] / cmake / OpenCVModule.cmake
1 # Local variables (set for each module):
2 #
3 # name       - short name in lower case i.e. core
4 # the_module - full name in lower case i.e. opencv_core
5
6 # Global variables:
7 #
8 # OPENCV_MODULE_${the_module}_LOCATION
9 # OPENCV_MODULE_${the_module}_BINARY_DIR
10 # OPENCV_MODULE_${the_module}_DESCRIPTION
11 # OPENCV_MODULE_${the_module}_CLASS - PUBLIC|INTERNAL|BINDINGS
12 # OPENCV_MODULE_${the_module}_HEADERS
13 # OPENCV_MODULE_${the_module}_SOURCES
14 # OPENCV_MODULE_${the_module}_DEPS - final flattened set of module dependencies
15 # OPENCV_MODULE_${the_module}_DEPS_TO_LINK - differs from above for world build only
16 # OPENCV_MODULE_${the_module}_DEPS_EXT - non-module dependencies
17 # OPENCV_MODULE_${the_module}_REQ_DEPS
18 # OPENCV_MODULE_${the_module}_OPT_DEPS
19 # OPENCV_MODULE_${the_module}_PRIVATE_REQ_DEPS
20 # OPENCV_MODULE_${the_module}_PRIVATE_OPT_DEPS
21 # OPENCV_MODULE_${the_module}_IS_PART_OF_WORLD
22 # HAVE_${the_module} - for fast check of module availability
23
24 # To control the setup of the module you could also set:
25 # the_description - text to be used as current module description
26 # OPENCV_MODULE_TYPE - STATIC|SHARED - set to force override global settings for current module
27 # OPENCV_MODULE_IS_PART_OF_WORLD - ON|OFF (default ON) - should the module be added to the opencv_world?
28 # BUILD_${the_module}_INIT - ON|OFF (default ON) - initial value for BUILD_${the_module}
29
30 # The verbose template for OpenCV module:
31 #
32 #   ocv_add_module(modname <dependencies>)
33 #   ocv_glob_module_sources(([EXCLUDE_CUDA] <extra sources&headers>)
34 #                          or glob them manually and ocv_set_module_sources(...)
35 #   ocv_module_include_directories(<extra include directories>)
36 #   ocv_create_module()
37 #   <add extra link dependencies, compiler options, etc>
38 #   ocv_add_precompiled_headers(${the_module})
39 #   <add extra installation rules>
40 #   ocv_add_accuracy_tests(<extra dependencies>)
41 #   ocv_add_perf_tests(<extra dependencies>)
42 #   ocv_add_samples(<extra dependencies>)
43 #
44 #
45 # If module have no "extra" then you can define it in one line:
46 #
47 #   ocv_define_module(modname <dependencies>)
48
49 # clean flags for modules enabled on previous cmake run
50 # this is necessary to correctly handle modules removal
51 foreach(mod ${OPENCV_MODULES_BUILD} ${OPENCV_MODULES_DISABLED_USER} ${OPENCV_MODULES_DISABLED_AUTO} ${OPENCV_MODULES_DISABLED_FORCE})
52   if(HAVE_${mod})
53     unset(HAVE_${mod} CACHE)
54   endif()
55   unset(OPENCV_MODULE_${mod}_REQ_DEPS CACHE)
56   unset(OPENCV_MODULE_${mod}_OPT_DEPS CACHE)
57   unset(OPENCV_MODULE_${mod}_PRIVATE_REQ_DEPS CACHE)
58   unset(OPENCV_MODULE_${mod}_PRIVATE_OPT_DEPS CACHE)
59   unset(OPENCV_MODULE_${mod}_LINK_DEPS CACHE)
60 endforeach()
61
62 # clean modules info which needs to be recalculated
63 set(OPENCV_MODULES_PUBLIC         "" CACHE INTERNAL "List of OpenCV modules marked for export")
64 set(OPENCV_MODULES_BUILD          "" CACHE INTERNAL "List of OpenCV modules included into the build")
65 set(OPENCV_MODULES_DISABLED_USER  "" CACHE INTERNAL "List of OpenCV modules explicitly disabled by user")
66 set(OPENCV_MODULES_DISABLED_AUTO  "" CACHE INTERNAL "List of OpenCV modules implicitly disabled due to dependencies")
67 set(OPENCV_MODULES_DISABLED_FORCE "" CACHE INTERNAL "List of OpenCV modules which can not be build in current configuration")
68 unset(OPENCV_WORLD_MODULES CACHE)
69
70 # adds dependencies to OpenCV module
71 # Usage:
72 #   add_dependencies(opencv_<name> [REQUIRED] [<list of dependencies>] [OPTIONAL <list of modules>])
73 # Notes:
74 # * <list of dependencies> - can include full names of modules or full pathes to shared/static libraries or cmake targets
75 macro(ocv_add_dependencies full_modname)
76   ocv_debug_message("ocv_add_dependencies(" ${full_modname} ${ARGN} ")")
77   #we don't clean the dependencies here to allow this macro several times for every module
78   foreach(d "REQUIRED" ${ARGN})
79     if(d STREQUAL "REQUIRED")
80       set(__depsvar OPENCV_MODULE_${full_modname}_REQ_DEPS)
81     elseif(d STREQUAL "OPTIONAL")
82       set(__depsvar OPENCV_MODULE_${full_modname}_OPT_DEPS)
83     elseif(d STREQUAL "PRIVATE_REQUIRED")
84       set(__depsvar OPENCV_MODULE_${full_modname}_PRIVATE_REQ_DEPS)
85     elseif(d STREQUAL "PRIVATE_OPTIONAL")
86       set(__depsvar OPENCV_MODULE_${full_modname}_PRIVATE_OPT_DEPS)
87     else()
88       list(APPEND ${__depsvar} "${d}")
89     endif()
90   endforeach()
91   unset(__depsvar)
92
93   ocv_list_unique(OPENCV_MODULE_${full_modname}_REQ_DEPS)
94   ocv_list_unique(OPENCV_MODULE_${full_modname}_OPT_DEPS)
95   ocv_list_unique(OPENCV_MODULE_${full_modname}_PRIVATE_REQ_DEPS)
96   ocv_list_unique(OPENCV_MODULE_${full_modname}_PRIVATE_OPT_DEPS)
97
98   set(OPENCV_MODULE_${full_modname}_REQ_DEPS ${OPENCV_MODULE_${full_modname}_REQ_DEPS}
99     CACHE INTERNAL "Required dependencies of ${full_modname} module")
100   set(OPENCV_MODULE_${full_modname}_OPT_DEPS ${OPENCV_MODULE_${full_modname}_OPT_DEPS}
101     CACHE INTERNAL "Optional dependencies of ${full_modname} module")
102   set(OPENCV_MODULE_${full_modname}_PRIVATE_REQ_DEPS ${OPENCV_MODULE_${full_modname}_PRIVATE_REQ_DEPS}
103     CACHE INTERNAL "Required private dependencies of ${full_modname} module")
104   set(OPENCV_MODULE_${full_modname}_PRIVATE_OPT_DEPS ${OPENCV_MODULE_${full_modname}_PRIVATE_OPT_DEPS}
105     CACHE INTERNAL "Optional private dependencies of ${full_modname} module")
106 endmacro()
107
108 # declare new OpenCV module in current folder
109 # Usage:
110 #   ocv_add_module(<name> [INTERNAL|BINDINGS] [REQUIRED] [<list of dependencies>] [OPTIONAL <list of optional dependencies>])
111 # Example:
112 #   ocv_add_module(yaom INTERNAL opencv_core opencv_highgui opencv_flann OPTIONAL opencv_cuda)
113 macro(ocv_add_module _name)
114   ocv_debug_message("ocv_add_module(" ${_name} ${ARGN} ")")
115   string(TOLOWER "${_name}" name)
116   string(REGEX REPLACE "^opencv_" "" ${name} "${name}")
117   set(the_module opencv_${name})
118
119   # the first pass - collect modules info, the second pass - create targets
120   if(OPENCV_INITIAL_PASS)
121     #guard agains redefinition
122     if(";${OPENCV_MODULES_BUILD};${OPENCV_MODULES_DISABLED_USER};" MATCHES ";${the_module};")
123       message(FATAL_ERROR "Redefinition of the ${the_module} module.
124   at:                    ${CMAKE_CURRENT_SOURCE_DIR}
125   previously defined at: ${OPENCV_MODULE_${the_module}_LOCATION}
126 ")
127     endif()
128
129     if(NOT DEFINED the_description)
130       set(the_description "The ${name} OpenCV module")
131     endif()
132
133     if(NOT DEFINED BUILD_${the_module}_INIT)
134       set(BUILD_${the_module}_INIT ON)
135     endif()
136
137     # create option to enable/disable this module
138     option(BUILD_${the_module} "Include ${the_module} module into the OpenCV build" ${BUILD_${the_module}_INIT})
139
140     # remember the module details
141     set(OPENCV_MODULE_${the_module}_DESCRIPTION "${the_description}" CACHE INTERNAL "Brief description of ${the_module} module")
142     set(OPENCV_MODULE_${the_module}_LOCATION    "${CMAKE_CURRENT_SOURCE_DIR}" CACHE INTERNAL "Location of ${the_module} module sources")
143
144     set(OPENCV_MODULE_${the_module}_LINK_DEPS "" CACHE INTERNAL "")
145
146     # parse list of dependencies
147     if("${ARGV1}" STREQUAL "INTERNAL" OR "${ARGV1}" STREQUAL "BINDINGS")
148       set(OPENCV_MODULE_${the_module}_CLASS "${ARGV1}" CACHE INTERNAL "The category of the module")
149       set(__ocv_argn__ ${ARGN})
150       list(REMOVE_AT __ocv_argn__ 0)
151       ocv_add_dependencies(${the_module} ${__ocv_argn__})
152       unset(__ocv_argn__)
153     else()
154       set(OPENCV_MODULE_${the_module}_CLASS "PUBLIC" CACHE INTERNAL "The category of the module")
155       ocv_add_dependencies(${the_module} ${ARGN})
156       if(BUILD_${the_module})
157         set(OPENCV_MODULES_PUBLIC ${OPENCV_MODULES_PUBLIC} "${the_module}" CACHE INTERNAL "List of OpenCV modules marked for export")
158       endif()
159     endif()
160
161     # add self to the world dependencies
162     if((NOT DEFINED OPENCV_MODULE_IS_PART_OF_WORLD AND NOT OPENCV_MODULE_${the_module}_CLASS STREQUAL "BINDINGS"
163         AND NOT OPENCV_PROCESSING_EXTRA_MODULES)
164         OR OPENCV_MODULE_IS_PART_OF_WORLD
165         )
166       set(OPENCV_MODULE_${the_module}_IS_PART_OF_WORLD ON CACHE INTERNAL "")
167       ocv_add_dependencies(opencv_world OPTIONAL ${the_module})
168     else()
169       set(OPENCV_MODULE_${the_module}_IS_PART_OF_WORLD OFF CACHE INTERNAL "")
170     endif()
171
172     if(BUILD_${the_module})
173       set(OPENCV_MODULES_BUILD ${OPENCV_MODULES_BUILD} "${the_module}" CACHE INTERNAL "List of OpenCV modules included into the build")
174     else()
175       set(OPENCV_MODULES_DISABLED_USER ${OPENCV_MODULES_DISABLED_USER} "${the_module}" CACHE INTERNAL "List of OpenCV modules explicitly disabled by user")
176     endif()
177
178     # TODO: add submodules if any
179
180     # stop processing of current file
181     return()
182   else()
183     set(OPENCV_MODULE_${the_module}_BINARY_DIR "${CMAKE_CURRENT_BINARY_DIR}" CACHE INTERNAL "")
184     if(NOT BUILD_${the_module})
185       return() # extra protection from redefinition
186     endif()
187     if((NOT OPENCV_MODULE_${the_module}_IS_PART_OF_WORLD AND NOT ${the_module} STREQUAL opencv_world) OR NOT ${BUILD_opencv_world})
188       project(${the_module})
189     endif()
190   endif()
191 endmacro()
192
193 # excludes module from current configuration
194 macro(ocv_module_disable module)
195   set(__modname ${module})
196   if(NOT __modname MATCHES "^opencv_")
197     set(__modname opencv_${module})
198   endif()
199   list(APPEND OPENCV_MODULES_DISABLED_FORCE "${__modname}")
200   set(HAVE_${__modname} OFF CACHE INTERNAL "Module ${__modname} can not be built in current configuration")
201   set(OPENCV_MODULE_${__modname}_LOCATION "${CMAKE_CURRENT_SOURCE_DIR}" CACHE INTERNAL "Location of ${__modname} module sources")
202   set(OPENCV_MODULES_DISABLED_FORCE "${OPENCV_MODULES_DISABLED_FORCE}" CACHE INTERNAL "List of OpenCV modules which can not be build in current configuration")
203   if(BUILD_${__modname})
204     # touch variable controlling build of the module to suppress "unused variable" CMake warning
205   endif()
206   unset(__modname)
207   return() # leave the current folder
208 endmacro()
209
210
211 # collect modules from specified directories
212 # NB: must be called only once!
213 macro(ocv_glob_modules)
214   if(DEFINED OPENCV_INITIAL_PASS)
215     message(FATAL_ERROR "OpenCV has already loaded its modules. Calling ocv_glob_modules second time is not allowed.")
216   endif()
217   set(__directories_observed "")
218
219   # collect modules
220   set(OPENCV_INITIAL_PASS ON)
221   set(OPENCV_PROCESSING_EXTRA_MODULES 0)
222   foreach(__path ${ARGN})
223     if("${__path}" STREQUAL "EXTRA")
224       set(OPENCV_PROCESSING_EXTRA_MODULES 1)
225     endif()
226     get_filename_component(__path "${__path}" ABSOLUTE)
227
228     list(FIND __directories_observed "${__path}" __pathIdx)
229     if(__pathIdx GREATER -1)
230       message(FATAL_ERROR "The directory ${__path} is observed for OpenCV modules second time.")
231     endif()
232     list(APPEND __directories_observed "${__path}")
233
234     file(GLOB __ocvmodules RELATIVE "${__path}" "${__path}/*")
235     if(__ocvmodules)
236       list(SORT __ocvmodules)
237       foreach(mod ${__ocvmodules})
238         get_filename_component(__modpath "${__path}/${mod}" ABSOLUTE)
239         if(EXISTS "${__modpath}/CMakeLists.txt")
240
241           list(FIND __directories_observed "${__modpath}" __pathIdx)
242           if(__pathIdx GREATER -1)
243             message(FATAL_ERROR "The module from ${__modpath} is already loaded.")
244           endif()
245           list(APPEND __directories_observed "${__modpath}")
246
247           add_subdirectory("${__modpath}" "${CMAKE_CURRENT_BINARY_DIR}/${mod}/.${mod}")
248         endif()
249       endforeach()
250     endif()
251   endforeach()
252   ocv_clear_vars(__ocvmodules __directories_observed __path __modpath __pathIdx)
253
254   # resolve dependencies
255   __ocv_resolve_dependencies()
256
257   # create modules
258   set(OPENCV_INITIAL_PASS OFF PARENT_SCOPE)
259   set(OPENCV_INITIAL_PASS OFF)
260   if(${BUILD_opencv_world})
261     add_subdirectory("${OPENCV_MODULE_opencv_world_LOCATION}" "${CMAKE_CURRENT_BINARY_DIR}/world")
262     foreach(m ${OPENCV_MODULES_BUILD})
263       if(NOT OPENCV_MODULE_${m}_IS_PART_OF_WORLD AND NOT ${m} STREQUAL opencv_world)
264         message(STATUS "Processing module ${m}...")
265         if(m MATCHES "^opencv_")
266           string(REGEX REPLACE "^opencv_" "" __shortname "${m}")
267           add_subdirectory("${OPENCV_MODULE_${m}_LOCATION}" "${CMAKE_CURRENT_BINARY_DIR}/${__shortname}")
268         else()
269           message(WARNING "Check module name: ${m}")
270           add_subdirectory("${OPENCV_MODULE_${m}_LOCATION}" "${CMAKE_CURRENT_BINARY_DIR}/${m}")
271         endif()
272       endif()
273     endforeach()
274   else()
275     foreach(m ${OPENCV_MODULES_BUILD})
276       if(m MATCHES "^opencv_")
277         string(REGEX REPLACE "^opencv_" "" __shortname "${m}")
278         add_subdirectory("${OPENCV_MODULE_${m}_LOCATION}" "${CMAKE_CURRENT_BINARY_DIR}/${__shortname}")
279       else()
280         message(WARNING "Check module name: ${m}")
281         add_subdirectory("${OPENCV_MODULE_${m}_LOCATION}" "${CMAKE_CURRENT_BINARY_DIR}/${m}")
282       endif()
283     endforeach()
284   endif()
285   unset(__shortname)
286 endmacro()
287
288
289 # disables OpenCV module with missing dependencies
290 function(__ocv_module_turn_off the_module)
291   list(REMOVE_ITEM OPENCV_MODULES_DISABLED_AUTO "${the_module}")
292   list(APPEND OPENCV_MODULES_DISABLED_AUTO "${the_module}")
293   list(REMOVE_ITEM OPENCV_MODULES_BUILD "${the_module}")
294   list(REMOVE_ITEM OPENCV_MODULES_PUBLIC "${the_module}")
295   set(HAVE_${the_module} OFF CACHE INTERNAL "Module ${the_module} can not be built in current configuration")
296
297   set(OPENCV_MODULES_DISABLED_AUTO "${OPENCV_MODULES_DISABLED_AUTO}" CACHE INTERNAL "")
298   set(OPENCV_MODULES_BUILD "${OPENCV_MODULES_BUILD}" CACHE INTERNAL "")
299   set(OPENCV_MODULES_PUBLIC "${OPENCV_MODULES_PUBLIC}" CACHE INTERNAL "")
300 endfunction()
301
302 # sort modules by dependencies
303 function(__ocv_sort_modules_by_deps __lst)
304   ocv_list_sort(${__lst})
305   set(${__lst}_ORDERED ${${__lst}} CACHE INTERNAL "")
306   set(__result "")
307   foreach (m ${${__lst}})
308     list(LENGTH __result __lastindex)
309     set(__index ${__lastindex})
310     foreach (__d ${__result})
311       set(__deps "${OPENCV_MODULE_${__d}_DEPS}")
312       if(";${__deps};" MATCHES ";${m};")
313         list(FIND __result "${__d}" __i)
314         if(__i LESS "${__index}")
315           set(__index "${__i}")
316         endif()
317       endif()
318     endforeach()
319     if(__index STREQUAL __lastindex)
320       list(APPEND __result "${m}")
321     else()
322       list(INSERT __result ${__index} "${m}")
323     endif()
324   endforeach()
325   set(${__lst} "${__result}" PARENT_SCOPE)
326 endfunction()
327
328 # resolve dependensies
329 function(__ocv_resolve_dependencies)
330   foreach(m ${OPENCV_MODULES_DISABLED_USER})
331     set(HAVE_${m} OFF CACHE INTERNAL "Module ${m} will not be built in current configuration")
332   endforeach()
333   foreach(m ${OPENCV_MODULES_BUILD})
334     set(HAVE_${m} ON CACHE INTERNAL "Module ${m} will be built in current configuration")
335   endforeach()
336
337   # disable MODULES with unresolved dependencies
338   set(has_changes ON)
339   while(has_changes)
340     set(has_changes OFF)
341     foreach(m ${OPENCV_MODULES_BUILD})
342       set(__deps ${OPENCV_MODULE_${m}_REQ_DEPS} ${OPENCV_MODULE_${m}_PRIVATE_REQ_DEPS})
343       while(__deps)
344         ocv_list_pop_front(__deps d)
345         string(TOLOWER "${d}" upper_d)
346         if(NOT (HAVE_${d} OR HAVE_${upper_d} OR TARGET ${d} OR EXISTS ${d}))
347           if(d MATCHES "^opencv_") # TODO Remove this condition in the future and use HAVE_ variables only
348             message(STATUS "Module ${m} disabled because ${d} dependency can't be resolved!")
349             __ocv_module_turn_off(${m})
350             set(has_changes ON)
351             break()
352           else()
353             message(STATUS "Assume that non-module dependency is available: ${d} (for module ${m})")
354           endif()
355         endif()
356       endwhile()
357     endforeach()
358   endwhile()
359
360 #  message(STATUS "List of active modules: ${OPENCV_MODULES_BUILD}")
361
362   foreach(m ${OPENCV_MODULES_BUILD})
363     set(deps_${m} ${OPENCV_MODULE_${m}_REQ_DEPS})
364     foreach(d ${OPENCV_MODULE_${m}_OPT_DEPS})
365       if(NOT (";${deps_${m}};" MATCHES ";${d};"))
366         if(HAVE_${d} OR TARGET ${d})
367           list(APPEND deps_${m} ${d})
368         endif()
369       endif()
370     endforeach()
371 #    message(STATUS "Initial deps of ${m} (w/o private deps): ${deps_${m}}")
372   endforeach()
373
374   # propagate dependencies
375   set(has_changes ON)
376   while(has_changes)
377     set(has_changes OFF)
378     foreach(m2 ${OPENCV_MODULES_BUILD}) # transfer deps of m2 to m
379       foreach(m ${OPENCV_MODULES_BUILD})
380         if((NOT m STREQUAL m2) AND ";${deps_${m}};" MATCHES ";${m2};")
381           foreach(d ${deps_${m2}})
382             if(NOT (";${deps_${m}};" MATCHES ";${d};"))
383 #              message(STATUS "  Transfer dependency ${d} from ${m2} to ${m}")
384               list(APPEND deps_${m} ${d})
385               set(has_changes ON)
386             endif()
387           endforeach()
388         endif()
389       endforeach()
390     endforeach()
391   endwhile()
392
393   # process private deps
394   foreach(m ${OPENCV_MODULES_BUILD})
395     foreach(d ${OPENCV_MODULE_${m}_PRIVATE_REQ_DEPS})
396       if(NOT (";${deps_${m}};" MATCHES ";${d};"))
397         list(APPEND deps_${m} ${d})
398       endif()
399     endforeach()
400     foreach(d ${OPENCV_MODULE_${m}_PRIVATE_OPT_DEPS})
401       if(NOT (";${deps_${m}};" MATCHES ";${d};"))
402         if(HAVE_${d} OR TARGET ${d})
403           list(APPEND deps_${m} ${d})
404         endif()
405       endif()
406     endforeach()
407   endforeach()
408
409   ocv_list_sort(OPENCV_MODULES_BUILD)
410
411   foreach(m ${OPENCV_MODULES_BUILD})
412 #    message(STATUS "FULL deps of ${m}: ${deps_${m}}")
413     set(OPENCV_MODULE_${m}_DEPS ${deps_${m}})
414     set(OPENCV_MODULE_${m}_DEPS_EXT ${deps_${m}})
415     ocv_list_filterout(OPENCV_MODULE_${m}_DEPS_EXT "^opencv_[^ ]+$")
416     if(OPENCV_MODULE_${m}_DEPS_EXT AND OPENCV_MODULE_${m}_DEPS)
417       list(REMOVE_ITEM OPENCV_MODULE_${m}_DEPS ${OPENCV_MODULE_${m}_DEPS_EXT})
418     endif()
419   endforeach()
420
421   # reorder dependencies
422   foreach(m ${OPENCV_MODULES_BUILD})
423     __ocv_sort_modules_by_deps(OPENCV_MODULE_${m}_DEPS)
424     ocv_list_sort(OPENCV_MODULE_${m}_DEPS_EXT)
425
426     set(LINK_DEPS ${OPENCV_MODULE_${m}_DEPS})
427
428     # process world
429     if(BUILD_opencv_world)
430       if(OPENCV_MODULE_${m}_IS_PART_OF_WORLD)
431         list(APPEND OPENCV_WORLD_MODULES ${m})
432       endif()
433       foreach(m2 ${OPENCV_MODULES_BUILD})
434         if(OPENCV_MODULE_${m2}_IS_PART_OF_WORLD)
435           if(";${LINK_DEPS};" MATCHES ";${m2};")
436             list(REMOVE_ITEM LINK_DEPS ${m2})
437             if(NOT (";${LINK_DEPS};" MATCHES ";opencv_world;") AND NOT (${m} STREQUAL opencv_world))
438               list(APPEND LINK_DEPS opencv_world)
439             endif()
440           endif()
441           if(${m} STREQUAL opencv_world)
442             list(APPEND OPENCV_MODULE_opencv_world_DEPS_EXT ${OPENCV_MODULE_${m2}_DEPS_EXT})
443           endif()
444         endif()
445       endforeach()
446     endif()
447
448     set(OPENCV_MODULE_${m}_DEPS ${OPENCV_MODULE_${m}_DEPS} CACHE INTERNAL "Flattened dependencies of ${m} module")
449     set(OPENCV_MODULE_${m}_DEPS_EXT ${OPENCV_MODULE_${m}_DEPS_EXT} CACHE INTERNAL "Extra dependencies of ${m} module")
450     set(OPENCV_MODULE_${m}_DEPS_TO_LINK ${LINK_DEPS} CACHE INTERNAL "Flattened dependencies of ${m} module (for linker)")
451
452 #    message(STATUS "  module deps of ${m}: ${OPENCV_MODULE_${m}_DEPS}")
453 #    message(STATUS "  module link deps of ${m}: ${OPENCV_MODULE_${m}_DEPS_TO_LINK}")
454 #    message(STATUS "  extra deps of ${m}: ${OPENCV_MODULE_${m}_DEPS_EXT}")
455 #    message(STATUS "")
456   endforeach()
457
458   __ocv_sort_modules_by_deps(OPENCV_MODULES_BUILD)
459
460   set(OPENCV_MODULES_PUBLIC        ${OPENCV_MODULES_PUBLIC}        CACHE INTERNAL "List of OpenCV modules marked for export")
461   set(OPENCV_MODULES_BUILD         ${OPENCV_MODULES_BUILD}         CACHE INTERNAL "List of OpenCV modules included into the build")
462   set(OPENCV_MODULES_DISABLED_AUTO ${OPENCV_MODULES_DISABLED_AUTO} CACHE INTERNAL "List of OpenCV modules implicitly disabled due to dependencies")
463   set(OPENCV_WORLD_MODULES         ${OPENCV_WORLD_MODULES}         CACHE INTERNAL "List of OpenCV modules included into the world")
464 endfunction()
465
466
467 # setup include paths for the list of passed modules
468 macro(ocv_include_modules)
469   foreach(d ${ARGN})
470     if(d MATCHES "^opencv_" AND HAVE_${d})
471       if (EXISTS "${OPENCV_MODULE_${d}_LOCATION}/include")
472         ocv_include_directories("${OPENCV_MODULE_${d}_LOCATION}/include")
473       endif()
474     elseif(EXISTS "${d}")
475       ocv_include_directories("${d}")
476     endif()
477   endforeach()
478 endmacro()
479
480 # setup include paths for the list of passed modules
481 macro(ocv_target_include_modules target)
482   foreach(d ${ARGN})
483     if(d MATCHES "^opencv_" AND HAVE_${d})
484       if (EXISTS "${OPENCV_MODULE_${d}_LOCATION}/include")
485         ocv_target_include_directories(${target} "${OPENCV_MODULE_${d}_LOCATION}/include")
486       endif()
487     elseif(EXISTS "${d}")
488       ocv_target_include_directories(${target} "${d}")
489     endif()
490   endforeach()
491 endmacro()
492
493 # setup include paths for the list of passed modules and recursively add dependent modules
494 macro(ocv_target_include_modules_recurse target)
495   foreach(d ${ARGN})
496     if(d MATCHES "^opencv_" AND HAVE_${d})
497       if (EXISTS "${OPENCV_MODULE_${d}_LOCATION}/include")
498         ocv_target_include_directories(${target} "${OPENCV_MODULE_${d}_LOCATION}/include")
499       endif()
500       if(OPENCV_MODULE_${d}_DEPS)
501         ocv_target_include_modules(${target} ${OPENCV_MODULE_${d}_DEPS})
502       endif()
503     elseif(EXISTS "${d}")
504       ocv_target_include_directories(${target} "${d}")
505     endif()
506   endforeach()
507 endmacro()
508
509 # setup include path for OpenCV headers for specified module
510 # ocv_module_include_directories(<extra include directories/extra include modules>)
511 macro(ocv_module_include_directories)
512   ocv_target_include_directories(${the_module}
513       "${OPENCV_MODULE_${the_module}_LOCATION}/include"
514       "${OPENCV_MODULE_${the_module}_LOCATION}/src"
515       "${CMAKE_CURRENT_BINARY_DIR}" # for precompiled headers
516       )
517   ocv_target_include_modules(${the_module} ${OPENCV_MODULE_${the_module}_DEPS} ${ARGN})
518 endmacro()
519
520
521 # sets header and source files for the current module
522 # NB: all files specified as headers will be installed
523 # Usage:
524 # ocv_set_module_sources([HEADERS] <list of files> [SOURCES] <list of files>)
525 macro(ocv_set_module_sources)
526   ocv_debug_message("ocv_set_module_sources(" ${ARGN} ")")
527
528   set(OPENCV_MODULE_${the_module}_HEADERS "")
529   set(OPENCV_MODULE_${the_module}_SOURCES "")
530
531   foreach(f "HEADERS" ${ARGN})
532     if(f STREQUAL "HEADERS" OR f STREQUAL "SOURCES")
533       set(__filesvar "OPENCV_MODULE_${the_module}_${f}")
534     else()
535       list(APPEND ${__filesvar} "${f}")
536     endif()
537   endforeach()
538
539   # the hacky way to embeed any files into the OpenCV without modification of its build system
540   if(COMMAND ocv_get_module_external_sources)
541     ocv_get_module_external_sources()
542   endif()
543
544   # use full paths for module to be independent from the module location
545   ocv_convert_to_full_paths(OPENCV_MODULE_${the_module}_HEADERS)
546
547   set(OPENCV_MODULE_${the_module}_HEADERS ${OPENCV_MODULE_${the_module}_HEADERS} CACHE INTERNAL "List of header files for ${the_module}")
548   set(OPENCV_MODULE_${the_module}_SOURCES ${OPENCV_MODULE_${the_module}_SOURCES} CACHE INTERNAL "List of source files for ${the_module}")
549 endmacro()
550
551 # finds and sets headers and sources for the standard OpenCV module
552 # Usage:
553 # ocv_glob_module_sources([EXCLUDE_CUDA] <extra sources&headers in the same format as used in ocv_set_module_sources>)
554 macro(ocv_glob_module_sources)
555   ocv_debug_message("ocv_glob_module_sources(" ${ARGN} ")")
556   set(_argn ${ARGN})
557   list(FIND _argn "EXCLUDE_CUDA" exclude_cuda)
558   if(NOT exclude_cuda EQUAL -1)
559     list(REMOVE_AT _argn ${exclude_cuda})
560   endif()
561
562   file(GLOB_RECURSE lib_srcs
563        "${CMAKE_CURRENT_LIST_DIR}/src/*.cpp"
564   )
565   file(GLOB_RECURSE lib_int_hdrs
566        "${CMAKE_CURRENT_LIST_DIR}/src/*.hpp"
567        "${CMAKE_CURRENT_LIST_DIR}/src/*.h"
568   )
569   file(GLOB lib_hdrs
570        "${CMAKE_CURRENT_LIST_DIR}/include/opencv2/*.hpp"
571        "${CMAKE_CURRENT_LIST_DIR}/include/opencv2/${name}/*.hpp"
572        "${CMAKE_CURRENT_LIST_DIR}/include/opencv2/${name}/*.h"
573   )
574   file(GLOB lib_hdrs_detail
575        "${CMAKE_CURRENT_LIST_DIR}/include/opencv2/${name}/detail/*.hpp"
576        "${CMAKE_CURRENT_LIST_DIR}/include/opencv2/${name}/detail/*.h"
577   )
578   if (APPLE)
579     file(GLOB_RECURSE lib_srcs_apple
580          "${CMAKE_CURRENT_LIST_DIR}/src/*.mm"
581     )
582     list(APPEND lib_srcs ${lib_srcs_apple})
583   endif()
584
585   ocv_source_group("Src" DIRBASE "${CMAKE_CURRENT_LIST_DIR}/src" FILES ${lib_srcs} ${lib_int_hdrs})
586   ocv_source_group("Include" DIRBASE "${CMAKE_CURRENT_LIST_DIR}/include" FILES ${lib_hdrs} ${lib_hdrs_detail})
587
588   set(lib_cuda_srcs "")
589   set(lib_cuda_hdrs "")
590   if(HAVE_CUDA AND exclude_cuda EQUAL -1)
591     file(GLOB lib_cuda_srcs
592          "${CMAKE_CURRENT_LIST_DIR}/src/cuda/*.cu"
593     )
594     file(GLOB lib_cuda_hdrs
595          "${CMAKE_CURRENT_LIST_DIR}/src/cuda/*.hpp"
596     )
597     source_group("Src\\Cuda"      FILES ${lib_cuda_srcs} ${lib_cuda_hdrs})
598   endif()
599
600   file(GLOB cl_kernels
601        "${CMAKE_CURRENT_LIST_DIR}/src/opencl/*.cl"
602   )
603   if(cl_kernels)
604     set(OCL_NAME opencl_kernels_${name})
605     ocv_include_directories(${OPENCL_INCLUDE_DIRS})
606     add_custom_command(
607       OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/${OCL_NAME}.cpp" "${CMAKE_CURRENT_BINARY_DIR}/${OCL_NAME}.hpp"
608       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"
609       DEPENDS ${cl_kernels} "${OpenCV_SOURCE_DIR}/cmake/cl2cpp.cmake")
610     ocv_source_group("Src\\opencl\\kernels" FILES ${cl_kernels})
611     ocv_source_group("Src\\opencl\\kernels\\autogenerated" FILES "${CMAKE_CURRENT_BINARY_DIR}/${OCL_NAME}.cpp" "${CMAKE_CURRENT_BINARY_DIR}/${OCL_NAME}.hpp")
612     list(APPEND lib_srcs ${cl_kernels} "${CMAKE_CURRENT_BINARY_DIR}/${OCL_NAME}.cpp" "${CMAKE_CURRENT_BINARY_DIR}/${OCL_NAME}.hpp")
613   endif()
614
615   ocv_set_module_sources(${_argn} HEADERS ${lib_hdrs} ${lib_hdrs_detail}
616                          SOURCES ${lib_srcs} ${lib_int_hdrs} ${lib_cuda_srcs} ${lib_cuda_hdrs})
617 endmacro()
618
619 # creates OpenCV module in current folder
620 # creates new target, configures standard dependencies, compilers flags, install rules
621 # Usage:
622 #   ocv_create_module(<extra link dependencies>)
623 #   ocv_create_module()
624 macro(ocv_create_module)
625   ocv_debug_message("ocv_create_module(" ${ARGN} ")")
626   set(OPENCV_MODULE_${the_module}_LINK_DEPS "${OPENCV_MODULE_${the_module}_LINK_DEPS};${ARGN}" CACHE INTERNAL "")
627   if(${BUILD_opencv_world} AND OPENCV_MODULE_${the_module}_IS_PART_OF_WORLD)
628     # nothing
629     set(the_module_target opencv_world)
630   else()
631     _ocv_create_module(${ARGN})
632     set(the_module_target ${the_module})
633   endif()
634 endmacro()
635
636 macro(_ocv_create_module)
637   # The condition we ought to be testing here is whether ocv_add_precompiled_headers will
638   # be called at some point in the future. We can't look into the future, though,
639   # so this will have to do.
640   if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/precomp.hpp" AND NOT ${the_module} STREQUAL opencv_world)
641     get_native_precompiled_header(${the_module} precomp.hpp)
642   endif()
643
644   ocv_add_library(${the_module} ${OPENCV_MODULE_TYPE} ${OPENCV_MODULE_${the_module}_HEADERS} ${OPENCV_MODULE_${the_module}_SOURCES}
645     "${OPENCV_CONFIG_FILE_INCLUDE_DIR}/cvconfig.h" "${OPENCV_CONFIG_FILE_INCLUDE_DIR}/opencv2/opencv_modules.hpp"
646     ${${the_module}_pch})
647   if(NOT the_module STREQUAL opencv_ts)
648     set_target_properties(${the_module} PROPERTIES COMPILE_DEFINITIONS OPENCV_NOSTL)
649   endif()
650
651   ocv_target_link_libraries(${the_module} ${OPENCV_MODULE_${the_module}_DEPS_TO_LINK})
652   ocv_target_link_libraries(${the_module} LINK_INTERFACE_LIBRARIES ${OPENCV_MODULE_${the_module}_DEPS_TO_LINK})
653   ocv_target_link_libraries(${the_module} ${OPENCV_MODULE_${the_module}_DEPS_EXT} ${OPENCV_LINKER_LIBS} ${IPP_LIBS} ${ARGN})
654   if (HAVE_CUDA)
655     ocv_target_link_libraries(${the_module} ${CUDA_LIBRARIES} ${CUDA_npp_LIBRARY})
656   endif()
657
658   add_dependencies(opencv_modules ${the_module})
659
660   if(ENABLE_SOLUTION_FOLDERS)
661     set_target_properties(${the_module} PROPERTIES FOLDER "modules")
662   endif()
663
664   set_target_properties(${the_module} PROPERTIES
665     OUTPUT_NAME "${the_module}${OPENCV_DLLVERSION}"
666     DEBUG_POSTFIX "${OPENCV_DEBUG_POSTFIX}"
667     ARCHIVE_OUTPUT_DIRECTORY ${LIBRARY_OUTPUT_PATH}
668     LIBRARY_OUTPUT_DIRECTORY ${LIBRARY_OUTPUT_PATH}
669     RUNTIME_OUTPUT_DIRECTORY ${EXECUTABLE_OUTPUT_PATH}
670     INSTALL_NAME_DIR lib
671   )
672
673   # For dynamic link numbering convenions
674   if(NOT ANDROID)
675     # Android SDK build scripts can include only .so files into final .apk
676     # As result we should not set version properties for Android
677     set_target_properties(${the_module} PROPERTIES
678       VERSION ${OPENCV_LIBVERSION}
679       SOVERSION ${OPENCV_SOVERSION}
680     )
681   endif()
682
683   if((NOT DEFINED OPENCV_MODULE_TYPE AND BUILD_SHARED_LIBS)
684       OR (DEFINED OPENCV_MODULE_TYPE AND OPENCV_MODULE_TYPE STREQUAL SHARED))
685     set_target_properties(${the_module} PROPERTIES DEFINE_SYMBOL CVAPI_EXPORTS)
686   endif()
687
688   if(MSVC)
689     if(CMAKE_CROSSCOMPILING)
690       set_target_properties(${the_module} PROPERTIES LINK_FLAGS "/NODEFAULTLIB:secchk")
691     endif()
692     set_target_properties(${the_module} PROPERTIES LINK_FLAGS "/NODEFAULTLIB:libc /DEBUG")
693   endif()
694
695   ocv_install_target(${the_module} EXPORT OpenCVModules
696     RUNTIME DESTINATION ${OPENCV_BIN_INSTALL_PATH} COMPONENT libs
697     LIBRARY DESTINATION ${OPENCV_LIB_INSTALL_PATH} COMPONENT libs
698     ARCHIVE DESTINATION ${OPENCV_LIB_INSTALL_PATH} COMPONENT dev
699     )
700
701   # only "public" headers need to be installed
702   if(OPENCV_MODULE_${the_module}_HEADERS AND ";${OPENCV_MODULES_PUBLIC};" MATCHES ";${the_module};")
703     foreach(hdr ${OPENCV_MODULE_${the_module}_HEADERS})
704       string(REGEX REPLACE "^.*opencv2/" "opencv2/" hdr2 "${hdr}")
705       if(NOT hdr2 MATCHES "opencv2/${the_module}/private.*" AND hdr2 MATCHES "^(opencv2/?.*)/[^/]+.h(..)?$" )
706         install(FILES ${hdr} DESTINATION "${OPENCV_INCLUDE_INSTALL_PATH}/${CMAKE_MATCH_1}" COMPONENT dev)
707       endif()
708     endforeach()
709   endif()
710   _ocv_add_precompiled_headers(${the_module})
711 endmacro()
712
713 # opencv precompiled headers macro (can add pch to modules and tests)
714 # this macro must be called after any "add_definitions" commands, otherwise precompiled headers will not work
715 # Usage:
716 # ocv_add_precompiled_headers(${the_module})
717 macro(_ocv_add_precompiled_headers the_target)
718   ocv_debug_message("ocv_add_precompiled_headers(" ${the_target} ${ARGN} ")")
719
720   if("${the_target}" MATCHES "^opencv_test_.*$")
721     SET(pch_path "test/test_")
722   elseif("${the_target}" MATCHES "^opencv_perf_.*$")
723     SET(pch_path "perf/perf_")
724   else()
725     SET(pch_path "src/")
726   endif()
727   ocv_add_precompiled_header_to_target(${the_target} "${CMAKE_CURRENT_SOURCE_DIR}/${pch_path}precomp.hpp")
728   unset(pch_path)
729 endmacro()
730
731 # short command for adding simple OpenCV module
732 # see ocv_add_module for argument details
733 # Usage:
734 # ocv_define_module(module_name  [INTERNAL] [EXCLUDE_CUDA] [REQUIRED] [<list of dependencies>] [OPTIONAL <list of optional dependencies>])
735 macro(ocv_define_module module_name)
736   ocv_debug_message("ocv_define_module(" ${module_name} ${ARGN} ")")
737   set(_argn ${ARGN})
738   set(exclude_cuda "")
739   foreach(arg ${_argn})
740     if("${arg}" STREQUAL "EXCLUDE_CUDA")
741       set(exclude_cuda "${arg}")
742       list(REMOVE_ITEM _argn ${arg})
743     endif()
744   endforeach()
745
746   ocv_add_module(${module_name} ${_argn})
747   ocv_glob_module_sources(${exclude_cuda})
748   ocv_module_include_directories()
749   ocv_create_module()
750
751   ocv_add_accuracy_tests()
752   ocv_add_perf_tests()
753   ocv_add_samples()
754 endmacro()
755
756 # ensures that all passed modules are available
757 # sets OCV_DEPENDENCIES_FOUND variable to TRUE/FALSE
758 macro(ocv_check_dependencies)
759   set(OCV_DEPENDENCIES_FOUND TRUE)
760   foreach(d ${ARGN})
761     if(d MATCHES "^opencv_[^ ]+$" AND NOT HAVE_${d})
762       set(OCV_DEPENDENCIES_FOUND FALSE)
763       break()
764     endif()
765   endforeach()
766 endmacro()
767
768 # auxiliary macro to parse arguments of ocv_add_accuracy_tests and ocv_add_perf_tests commands
769 macro(__ocv_parse_test_sources tests_type)
770   set(OPENCV_${tests_type}_${the_module}_SOURCES "")
771   set(OPENCV_${tests_type}_${the_module}_DEPS "")
772   set(__file_group_name "")
773   set(__file_group_sources "")
774   foreach(arg "DEPENDS_ON" ${ARGN} "FILES")
775     if(arg STREQUAL "FILES")
776       set(__currentvar "__file_group_sources")
777       if(__file_group_name AND __file_group_sources)
778         source_group("${__file_group_name}" FILES ${__file_group_sources})
779         list(APPEND OPENCV_${tests_type}_${the_module}_SOURCES ${__file_group_sources})
780       endif()
781       set(__file_group_name "")
782       set(__file_group_sources "")
783     elseif(arg STREQUAL "DEPENDS_ON")
784       set(__currentvar "OPENCV_${tests_type}_${the_module}_DEPS")
785     elseif("${__currentvar}" STREQUAL "__file_group_sources" AND NOT __file_group_name)
786       set(__file_group_name "${arg}")
787     else()
788       list(APPEND ${__currentvar} "${arg}")
789     endif()
790   endforeach()
791   unset(__file_group_name)
792   unset(__file_group_sources)
793   unset(__currentvar)
794 endmacro()
795
796 # this is a command for adding OpenCV performance tests to the module
797 # ocv_add_perf_tests(<extra_dependencies>)
798 function(ocv_add_perf_tests)
799   ocv_debug_message("ocv_add_perf_tests(" ${ARGN} ")")
800
801   set(perf_path "${CMAKE_CURRENT_LIST_DIR}/perf")
802   if(BUILD_PERF_TESTS AND EXISTS "${perf_path}")
803     __ocv_parse_test_sources(PERF ${ARGN})
804
805     # opencv_imgcodecs is required for imread/imwrite
806     set(perf_deps ${the_module} opencv_ts opencv_imgcodecs ${OPENCV_MODULE_${the_module}_DEPS} ${OPENCV_MODULE_opencv_ts_DEPS})
807     ocv_check_dependencies(${perf_deps})
808
809     if(OCV_DEPENDENCIES_FOUND)
810       set(the_target "opencv_perf_${name}")
811       # project(${the_target})
812
813       if(NOT OPENCV_PERF_${the_module}_SOURCES)
814         file(GLOB_RECURSE perf_srcs "${perf_path}/*.cpp")
815         file(GLOB_RECURSE perf_hdrs "${perf_path}/*.hpp" "${perf_path}/*.h")
816         ocv_source_group("Src" DIRBASE "${perf_path}" FILES ${perf_srcs})
817         ocv_source_group("Include" DIRBASE "${perf_path}" FILES ${perf_hdrs})
818         set(OPENCV_PERF_${the_module}_SOURCES ${perf_srcs} ${perf_hdrs})
819       endif()
820
821       if(NOT BUILD_opencv_world)
822         get_native_precompiled_header(${the_target} perf_precomp.hpp)
823       endif()
824
825       ocv_add_executable(${the_target} ${OPENCV_PERF_${the_module}_SOURCES} ${${the_target}_pch})
826       ocv_target_include_modules(${the_target} ${perf_deps} "${perf_path}")
827       ocv_target_link_libraries(${the_target} ${OPENCV_MODULE_${the_module}_DEPS} ${perf_deps} ${OPENCV_LINKER_LIBS})
828       add_dependencies(opencv_perf_tests ${the_target})
829
830       # Additional target properties
831       set_target_properties(${the_target} PROPERTIES
832         DEBUG_POSTFIX "${OPENCV_DEBUG_POSTFIX}"
833         RUNTIME_OUTPUT_DIRECTORY "${EXECUTABLE_OUTPUT_PATH}"
834       )
835
836       if(ENABLE_SOLUTION_FOLDERS)
837         set_target_properties(${the_target} PROPERTIES FOLDER "tests performance")
838       endif()
839
840       if(NOT BUILD_opencv_world)
841         _ocv_add_precompiled_headers(${the_target})
842       endif()
843     else(OCV_DEPENDENCIES_FOUND)
844       # TODO: warn about unsatisfied dependencies
845     endif(OCV_DEPENDENCIES_FOUND)
846     if(INSTALL_TESTS)
847       install(TARGETS ${the_target} RUNTIME DESTINATION ${OPENCV_TEST_INSTALL_PATH} COMPONENT tests)
848     endif()
849   endif()
850 endfunction()
851
852 # this is a command for adding OpenCV accuracy/regression tests to the module
853 # ocv_add_accuracy_tests([FILES <source group name> <list of sources>] [DEPENDS_ON] <list of extra dependencies>)
854 function(ocv_add_accuracy_tests)
855   ocv_debug_message("ocv_add_accuracy_tests(" ${ARGN} ")")
856
857   set(test_path "${CMAKE_CURRENT_LIST_DIR}/test")
858   if(BUILD_TESTS AND EXISTS "${test_path}")
859     __ocv_parse_test_sources(TEST ${ARGN})
860
861     # opencv_imgcodecs is required for imread/imwrite
862     set(test_deps ${the_module} opencv_ts opencv_imgcodecs opencv_videoio ${OPENCV_MODULE_${the_module}_DEPS} ${OPENCV_MODULE_opencv_ts_DEPS})
863     ocv_check_dependencies(${test_deps})
864     if(OCV_DEPENDENCIES_FOUND)
865       set(the_target "opencv_test_${name}")
866       # project(${the_target})
867
868       if(NOT OPENCV_TEST_${the_module}_SOURCES)
869         file(GLOB_RECURSE test_srcs "${test_path}/*.cpp")
870         file(GLOB_RECURSE test_hdrs "${test_path}/*.hpp" "${test_path}/*.h")
871         ocv_source_group("Src" DIRBASE "${test_path}" FILES ${test_srcs})
872         ocv_source_group("Include" DIRBASE "${test_path}" FILES ${test_hdrs})
873         set(OPENCV_TEST_${the_module}_SOURCES ${test_srcs} ${test_hdrs})
874       endif()
875
876       if(NOT BUILD_opencv_world)
877         get_native_precompiled_header(${the_target} test_precomp.hpp)
878       endif()
879
880       ocv_add_executable(${the_target} ${OPENCV_TEST_${the_module}_SOURCES} ${${the_target}_pch})
881       ocv_target_include_modules(${the_target} ${test_deps} "${test_path}")
882       ocv_target_link_libraries(${the_target} ${OPENCV_MODULE_${the_module}_DEPS} ${test_deps} ${OPENCV_LINKER_LIBS})
883       add_dependencies(opencv_tests ${the_target})
884
885       # Additional target properties
886       set_target_properties(${the_target} PROPERTIES
887         DEBUG_POSTFIX "${OPENCV_DEBUG_POSTFIX}"
888         RUNTIME_OUTPUT_DIRECTORY "${EXECUTABLE_OUTPUT_PATH}"
889       )
890
891       if(ENABLE_SOLUTION_FOLDERS)
892         set_target_properties(${the_target} PROPERTIES FOLDER "tests accuracy")
893       endif()
894
895       enable_testing()
896       get_target_property(LOC ${the_target} LOCATION)
897       add_test(${the_target} "${LOC}")
898
899       if(NOT BUILD_opencv_world)
900         _ocv_add_precompiled_headers(${the_target})
901       endif()
902     else(OCV_DEPENDENCIES_FOUND)
903       # TODO: warn about unsatisfied dependencies
904     endif(OCV_DEPENDENCIES_FOUND)
905
906     if(INSTALL_TESTS)
907       install(TARGETS ${the_target} RUNTIME DESTINATION ${OPENCV_TEST_INSTALL_PATH} COMPONENT tests)
908     endif()
909   endif()
910 endfunction()
911
912 function(ocv_add_samples)
913   ocv_debug_message("ocv_add_samples(" ${ARGN} ")")
914
915   set(samples_path "${CMAKE_CURRENT_SOURCE_DIR}/samples")
916   string(REGEX REPLACE "^opencv_" "" module_id ${the_module})
917
918   if(BUILD_EXAMPLES AND EXISTS "${samples_path}")
919     set(samples_deps ${the_module} ${OPENCV_MODULE_${the_module}_DEPS} opencv_imgcodecs opencv_videoio opencv_highgui ${ARGN})
920     ocv_check_dependencies(${samples_deps})
921
922     if(OCV_DEPENDENCIES_FOUND)
923       file(GLOB sample_sources "${samples_path}/*.cpp")
924
925       foreach(source ${sample_sources})
926         get_filename_component(name "${source}" NAME_WE)
927         set(the_target "example_${module_id}_${name}")
928
929         ocv_add_executable(${the_target} "${source}")
930         ocv_target_include_modules(${the_target} ${samples_deps})
931         ocv_target_link_libraries(${the_target} ${samples_deps})
932         set_target_properties(${the_target} PROPERTIES PROJECT_LABEL "(sample) ${name}")
933
934         if(ENABLE_SOLUTION_FOLDERS)
935           set_target_properties(${the_target} PROPERTIES
936             OUTPUT_NAME "${module_id}-example-${name}"
937             FOLDER "samples/${module_id}")
938         endif()
939
940         if(WIN32)
941           install(TARGETS ${the_target} RUNTIME DESTINATION "samples/${module_id}" COMPONENT samples)
942         endif()
943       endforeach()
944     endif()
945   endif()
946
947   if(INSTALL_C_EXAMPLES AND NOT WIN32 AND EXISTS "${samples_path}")
948     file(GLOB sample_files "${samples_path}/*")
949     install(FILES ${sample_files}
950             DESTINATION ${OPENCV_SAMPLES_SRC_INSTALL_PATH}/${module_id}
951             PERMISSIONS OWNER_READ GROUP_READ WORLD_READ COMPONENT samples)
952   endif()
953 endfunction()