Merge pull request #16150 from alalek:cmake_avoid_deprecated_link_private

* cmake: avoid deprecated LINK_PRIVATE/LINK_PUBLIC

see CMP0023 (CMake 2.8.12+)

* cmake: fix 3rdparty list

- don't include OpenCV modules

3rdparty/openvx/hal/CMakeLists.txt

@@ -5,7 +5,7 @@ target_include_directories(openvx_hal PUBLIC
   ${CMAKE_SOURCE_DIR}/modules/core/include
   ${CMAKE_SOURCE_DIR}/modules/imgproc/include
   ${OPENVX_INCLUDE_DIR})
-target_link_libraries(openvx_hal LINK_PUBLIC ${OPENVX_LIBRARIES})
+target_link_libraries(openvx_hal PUBLIC ${OPENVX_LIBRARIES})
 set_target_properties(openvx_hal PROPERTIES ARCHIVE_OUTPUT_DIRECTORY ${3P_LIBRARY_OUTPUT_PATH})
 if(NOT BUILD_SHARED_LIBS)
   ocv_install_target(openvx_hal EXPORT OpenCVModules ARCHIVE DESTINATION ${OPENCV_3P_LIB_INSTALL_PATH} COMPONENT dev)

cmake/OpenCVDetectCUDA.cmake

@@ -12,7 +12,7 @@ endif()
 if(((NOT CMAKE_VERSION VERSION_LESS "3.9.0")  # requires https://gitlab.kitware.com/cmake/cmake/merge_requests/663
       OR OPENCV_CUDA_FORCE_EXTERNAL_CMAKE_MODULE)
     AND NOT OPENCV_CUDA_FORCE_BUILTIN_CMAKE_MODULE)
-  ocv_update(CUDA_LINK_LIBRARIES_KEYWORD "LINK_PRIVATE")
+  ocv_update(CUDA_LINK_LIBRARIES_KEYWORD "PRIVATE")
   find_host_package(CUDA "${MIN_VER_CUDA}" QUIET)
 else()
   # Use OpenCV's patched "FindCUDA" module

cmake/OpenCVModule.cmake

@@ -934,11 +934,15 @@ macro(_ocv_create_module)
   set_source_files_properties(${OPENCV_MODULE_${the_module}_HEADERS} ${OPENCV_MODULE_${the_module}_SOURCES} ${${the_module}_pch}
     PROPERTIES LABELS "${OPENCV_MODULE_${the_module}_LABEL};Module")
 
-  ocv_target_link_libraries(${the_module} LINK_PUBLIC ${OPENCV_MODULE_${the_module}_DEPS_TO_LINK})
-  ocv_target_link_libraries(${the_module} LINK_PUBLIC ${OPENCV_MODULE_${the_module}_DEPS_EXT})
-  ocv_target_link_libraries(${the_module} LINK_PRIVATE ${OPENCV_LINKER_LIBS} ${OPENCV_HAL_LINKER_LIBS} ${IPP_LIBS} ${ARGN})
+  ocv_target_link_libraries(${the_module} PUBLIC    ${OPENCV_MODULE_${the_module}_DEPS_TO_LINK}
+                                          INTERFACE ${OPENCV_MODULE_${the_module}_DEPS_TO_LINK}
+  )
+  ocv_target_link_libraries(${the_module} PUBLIC    ${OPENCV_MODULE_${the_module}_DEPS_EXT}
+                                          INTERFACE ${OPENCV_MODULE_${the_module}_DEPS_EXT}
+  )
+  ocv_target_link_libraries(${the_module} PRIVATE ${OPENCV_LINKER_LIBS} ${OPENCV_HAL_LINKER_LIBS} ${IPP_LIBS} ${ARGN})
   if (HAVE_CUDA)
-    ocv_target_link_libraries(${the_module} LINK_PRIVATE ${CUDA_LIBRARIES} ${CUDA_npp_LIBRARY})
+    ocv_target_link_libraries(${the_module} PRIVATE ${CUDA_LIBRARIES} ${CUDA_npp_LIBRARY})
   endif()
 
   if(OPENCV_MODULE_${the_module}_COMPILE_DEFINITIONS)
@@ -1145,7 +1149,7 @@ function(ocv_add_perf_tests)
       source_group("Src" FILES "${${the_target}_pch}")
       ocv_add_executable(${the_target} ${OPENCV_PERF_${the_module}_SOURCES} ${${the_target}_pch})
       ocv_target_include_modules(${the_target} ${perf_deps})
-      ocv_target_link_libraries(${the_target} LINK_PRIVATE ${perf_deps} ${OPENCV_MODULE_${the_module}_DEPS} ${OPENCV_LINKER_LIBS} ${OPENCV_PERF_${the_module}_DEPS})
+      ocv_target_link_libraries(${the_target} PRIVATE ${perf_deps} ${OPENCV_MODULE_${the_module}_DEPS} ${OPENCV_LINKER_LIBS} ${OPENCV_PERF_${the_module}_DEPS})
       add_dependencies(opencv_perf_tests ${the_target})
 
       set_target_properties(${the_target} PROPERTIES LABELS "${OPENCV_MODULE_${the_module}_LABEL};PerfTest")
@@ -1226,7 +1230,7 @@ function(ocv_add_accuracy_tests)
       if(EXISTS "${CMAKE_CURRENT_BINARY_DIR}/test")
         ocv_target_include_directories(${the_target} "${CMAKE_CURRENT_BINARY_DIR}/test")
       endif()
-      ocv_target_link_libraries(${the_target} LINK_PRIVATE ${test_deps} ${OPENCV_MODULE_${the_module}_DEPS} ${OPENCV_LINKER_LIBS} ${OPENCV_TEST_${the_module}_DEPS})
+      ocv_target_link_libraries(${the_target} PRIVATE ${test_deps} ${OPENCV_MODULE_${the_module}_DEPS} ${OPENCV_LINKER_LIBS} ${OPENCV_TEST_${the_module}_DEPS})
       add_dependencies(opencv_tests ${the_target})
 
       set_target_properties(${the_target} PROPERTIES LABELS "${OPENCV_MODULE_${the_module}_LABEL};AccuracyTest")
@@ -1287,7 +1291,7 @@ function(ocv_add_samples)
 
         ocv_add_executable(${the_target} "${source}")
         ocv_target_include_modules(${the_target} ${samples_deps})
-        ocv_target_link_libraries(${the_target} LINK_PRIVATE ${samples_deps})
+        ocv_target_link_libraries(${the_target} PRIVATE ${samples_deps})
 
         set_target_properties(${the_target} PROPERTIES
           PROJECT_LABEL "(sample) ${name}"

cmake/OpenCVUtils.cmake

@@ -1440,12 +1440,14 @@ endmacro()
 function(ocv_target_link_libraries target)
   set(LINK_DEPS ${ARGN})
   _ocv_fix_target(target)
-  set(LINK_MODE "LINK_PRIVATE")
+  set(LINK_MODE "PRIVATE")
   set(LINK_PENDING "")
   foreach(dep ${LINK_DEPS})
     if(" ${dep}" STREQUAL " ${target}")
       # prevent "link to itself" warning (world problem)
-    elseif(" ${dep}" STREQUAL " LINK_PRIVATE" OR " ${dep}" STREQUAL "LINK_PUBLIC")
+    elseif(" ${dep}" STREQUAL " LINK_PRIVATE" OR " ${dep}" STREQUAL " LINK_PUBLIC"  # deprecated
+        OR " ${dep}" STREQUAL " PRIVATE" OR " ${dep}" STREQUAL " PUBLIC" OR " ${dep}" STREQUAL " INTERFACE"
+    )
       if(NOT LINK_PENDING STREQUAL "")
         __ocv_push_target_link_libraries(${LINK_MODE} ${LINK_PENDING})
         set(LINK_PENDING "")
@@ -1584,7 +1586,10 @@ macro(ocv_get_all_libs _modules _extra _3rdparty)
         endif()
         if (TARGET ${dep})
           get_target_property(_type ${dep} TYPE)
-          if(_type STREQUAL "STATIC_LIBRARY" AND BUILD_SHARED_LIBS OR _type STREQUAL "INTERFACE_LIBRARY")
+          if((_type STREQUAL "STATIC_LIBRARY" AND BUILD_SHARED_LIBS)
+              OR _type STREQUAL "INTERFACE_LIBRARY"
+              OR DEFINED OPENCV_MODULE_${dep}_LOCATION  # OpenCV modules
+          )
             # nothing
           else()
             get_target_property(_output ${dep} IMPORTED_LOCATION)

cmake/android/android_ant_projects.cmake

@@ -194,7 +194,7 @@ macro(add_android_project target path)
         add_library(${JNI_LIB_NAME} SHARED ${android_proj_jni_files})
         ocv_target_include_modules_recurse(${JNI_LIB_NAME} ${android_proj_NATIVE_DEPS})
         ocv_target_include_directories(${JNI_LIB_NAME} "${path}/jni")
-        ocv_target_link_libraries(${JNI_LIB_NAME} LINK_PRIVATE ${OPENCV_LINKER_LIBS} ${android_proj_NATIVE_DEPS})
+        ocv_target_link_libraries(${JNI_LIB_NAME} PRIVATE ${OPENCV_LINKER_LIBS} ${android_proj_NATIVE_DEPS})
 
         set_target_properties(${JNI_LIB_NAME} PROPERTIES
             OUTPUT_NAME "${JNI_LIB_NAME}"

modules/core/CMakeLists.txt

@@ -80,7 +80,7 @@ endif()
 
 ocv_create_module(${extra_libs})
 
-ocv_target_link_libraries(${the_module} LINK_PRIVATE
+ocv_target_link_libraries(${the_module} PRIVATE
     "${ZLIB_LIBRARIES}" "${OPENCL_LIBRARIES}" "${VA_LIBRARIES}"
     "${LAPACK_LIBRARIES}" "${CPUFEATURES_LIBRARIES}" "${HALIDE_LIBRARIES}"
     "${ITT_LIBRARIES}"

modules/cudev/test/CMakeLists.txt

@@ -16,7 +16,7 @@ if(OCV_DEPENDENCIES_FOUND)
   ocv_cuda_filter_options()
 
   CUDA_ADD_EXECUTABLE(${the_target} ${OPENCV_TEST_${the_module}_SOURCES})
-  ocv_target_link_libraries(${the_target} LINK_PRIVATE
+  ocv_target_link_libraries(${the_target} PRIVATE
       ${test_deps} ${OPENCV_LINKER_LIBS} ${CUDA_LIBRARIES}
   )
   add_dependencies(opencv_tests ${the_target})

modules/java/jni/CMakeLists.txt

@@ -44,16 +44,16 @@ if(BUILD_FAT_JAVA_LIB)
   endif()
   if(APPLE)
     foreach(_dep ${__deps})
-      ocv_target_link_libraries(${the_module} LINK_PRIVATE -Wl,-force_load "${_dep}")
+      ocv_target_link_libraries(${the_module} PRIVATE -Wl,-force_load "${_dep}")
     endforeach()
   elseif(((CV_GCC OR CV_CLANG OR UNIX) OR (OPENCV_FORCE_FAT_JAVA_LIB_LD_RULES)) AND (NOT OPENCV_SKIP_FAT_JAVA_LIB_LD_RULES))
-    ocv_target_link_libraries(${the_module} LINK_PRIVATE -Wl,-whole-archive ${__deps} -Wl,-no-whole-archive)
+    ocv_target_link_libraries(${the_module} PRIVATE -Wl,-whole-archive ${__deps} -Wl,-no-whole-archive)
   else()
-    ocv_target_link_libraries(${the_module} LINK_PRIVATE ${__deps})
+    ocv_target_link_libraries(${the_module} PRIVATE ${__deps})
   endif()
-  ocv_target_link_libraries(${the_module} LINK_PRIVATE ${__extradeps} ${OPENCV_LINKER_LIBS})
+  ocv_target_link_libraries(${the_module} PRIVATE ${__extradeps} ${OPENCV_LINKER_LIBS})
 else()
-  ocv_target_link_libraries(${the_module} LINK_PRIVATE ${__deps} ${OPENCV_LINKER_LIBS})
+  ocv_target_link_libraries(${the_module} PRIVATE ${__deps} ${OPENCV_LINKER_LIBS})
 endif()
 
 # Additional target properties
@@ -66,8 +66,12 @@ set_target_properties(${the_module} PROPERTIES
     )
 
 if(ANDROID)
-  ocv_target_link_libraries(${the_module} LINK_PUBLIC jnigraphics) # for Mat <=> Bitmap converters
-  ocv_target_link_libraries(${the_module} LINK_PUBLIC log dl z)
+  ocv_target_link_libraries(${the_module} PUBLIC    jnigraphics  # for Mat <=> Bitmap converters
+                                          INTERFACE jnigraphics
+  )
+  ocv_target_link_libraries(${the_module} PUBLIC    log dl z
+                                          INTERFACE log dl z
+  )
 
   # force strip library after the build command
   # because samples and tests will make a copy of the library before install

modules/python/common.cmake

@@ -44,9 +44,9 @@ if(APPLE)
   set_target_properties(${the_module} PROPERTIES LINK_FLAGS "-undefined dynamic_lookup")
 elseif(WIN32 OR OPENCV_FORCE_PYTHON_LIBS)
   if(${PYTHON}_DEBUG_LIBRARIES AND NOT ${PYTHON}_LIBRARIES MATCHES "optimized.*debug")
-    ocv_target_link_libraries(${the_module} LINK_PRIVATE debug ${${PYTHON}_DEBUG_LIBRARIES} optimized ${${PYTHON}_LIBRARIES})
+    ocv_target_link_libraries(${the_module} PRIVATE debug ${${PYTHON}_DEBUG_LIBRARIES} optimized ${${PYTHON}_LIBRARIES})
   else()
-    ocv_target_link_libraries(${the_module} LINK_PRIVATE ${${PYTHON}_LIBRARIES})
+    ocv_target_link_libraries(${the_module} PRIVATE ${${PYTHON}_LIBRARIES})
   endif()
 endif()
 
@@ -54,7 +54,7 @@ if(TARGET gen_opencv_python_source)
   set(deps ${OPENCV_MODULE_${the_module}_DEPS})
   list(REMOVE_ITEM deps opencv_python_bindings_generator) # don't add dummy module to target_link_libraries list
 endif()
-ocv_target_link_libraries(${the_module} LINK_PRIVATE ${deps})
+ocv_target_link_libraries(${the_module} PRIVATE ${deps})
 
 if(DEFINED ${PYTHON}_CVPY_SUFFIX)
   set(CVPY_SUFFIX "${${PYTHON}_CVPY_SUFFIX}")

modules/viz/CMakeLists.txt

@@ -27,10 +27,10 @@ endif()
 ocv_warnings_disable(CMAKE_CXX_FLAGS -Winconsistent-missing-override -Wsuggest-override)
 
 ocv_define_module(viz opencv_core WRAP python)
-ocv_target_link_libraries(${the_module} LINK_PRIVATE ${VTK_LIBRARIES})
+ocv_target_link_libraries(${the_module} PRIVATE ${VTK_LIBRARIES})
 
 if(APPLE AND BUILD_opencv_viz)
-  ocv_target_link_libraries(${the_module} LINK_PRIVATE "-framework Cocoa")
+  ocv_target_link_libraries(${the_module} PRIVATE "-framework Cocoa")
 endif()
 
 if(TARGET opencv_test_viz)

samples/CMakeLists.example.in

@@ -39,4 +39,4 @@ message(STATUS "    include path: ${OpenCV_INCLUDE_DIRS}")
 add_executable(${EXAMPLE_NAME} "${EXAMPLE_FILE}")
 
 # Link your application with OpenCV libraries
-target_link_libraries(${EXAMPLE_NAME} LINK_PRIVATE ${OpenCV_LIBS})
+target_link_libraries(${EXAMPLE_NAME} PRIVATE ${OpenCV_LIBS})

samples/android/CMakeLists.txt

@@ -20,7 +20,7 @@ add_subdirectory(tutorial-4-opencl)
 if(HAVE_opencv_highgui)
   add_executable(hello-android hello-android/main.cpp)
   ocv_target_include_modules_recurse(hello-android opencv_imgcodecs opencv_videoio opencv_highgui opencv_core opencv_imgproc)
-  ocv_target_link_libraries(hello-android LINK_PRIVATE ${OPENCV_LINKER_LIBS} opencv_imgcodecs opencv_videoio opencv_highgui opencv_core opencv_imgproc)
+  ocv_target_link_libraries(hello-android PRIVATE ${OPENCV_LINKER_LIBS} opencv_imgcodecs opencv_videoio opencv_highgui opencv_core opencv_imgproc)
   set_target_properties(hello-android PROPERTIES OUTPUT_NAME hello-android RUNTIME_OUTPUT_DIRECTORY "${EXECUTABLE_OUTPUT_PATH}")
   add_dependencies(opencv_android_examples hello-android)
 endif()

samples/cpp/CMakeLists.txt

@@ -46,12 +46,12 @@ foreach(sample_filename ${cpp_samples})
     set(package "tutorial")
   endif()
   ocv_define_sample(tgt ${sample_filename} ${package})
-  ocv_target_link_libraries(${tgt} LINK_PRIVATE ${OPENCV_LINKER_LIBS} ${OPENCV_CPP_SAMPLES_REQUIRED_DEPS})
+  ocv_target_link_libraries(${tgt} PRIVATE ${OPENCV_LINKER_LIBS} ${OPENCV_CPP_SAMPLES_REQUIRED_DEPS})
   if(sample_filename MATCHES "/gpu/" AND HAVE_opencv_cudaarithm AND HAVE_opencv_cuda_filters)
-    ocv_target_link_libraries(${tgt} LINK_PRIVATE opencv_cudaarithm opencv_cudafilters)
+    ocv_target_link_libraries(${tgt} PRIVATE opencv_cudaarithm opencv_cudafilters)
   endif()
   if(sample_filename MATCHES "/viz/")
-    ocv_target_link_libraries(${tgt} LINK_PRIVATE ${VTK_LIBRARIES})
+    ocv_target_link_libraries(${tgt} PRIVATE ${VTK_LIBRARIES})
     target_compile_definitions(${tgt} PRIVATE -DUSE_VTK)
   endif()
   if(HAVE_OPENGL AND sample_filename MATCHES "detect_mser")

samples/cpp/example_cmake/CMakeLists.txt

@@ -27,4 +27,4 @@ endif()
 add_executable(opencv_example example.cpp)
 
 # Link your application with OpenCV libraries
-target_link_libraries(opencv_example LINK_PRIVATE ${OpenCV_LIBS})
+target_link_libraries(opencv_example PRIVATE ${OpenCV_LIBS})

samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/CMakeLists.txt

@@ -17,5 +17,5 @@ ocv_include_modules_recurse(${OPENCV_CPP_SAMPLES_REQUIRED_DEPS})
 add_executable( ${target}pnp_registration ${sample_dir}main_registration.cpp ${sample_pnplib} )
 add_executable( ${target}pnp_detection ${sample_dir}main_detection.cpp ${sample_pnplib} )
 
-ocv_target_link_libraries(${target}pnp_registration LINK_PRIVATE ${OPENCV_LINKER_LIBS} ${OPENCV_CPP_SAMPLES_REQUIRED_DEPS})
-ocv_target_link_libraries(${target}pnp_detection LINK_PRIVATE ${OPENCV_LINKER_LIBS} ${OPENCV_CPP_SAMPLES_REQUIRED_DEPS})
+ocv_target_link_libraries(${target}pnp_registration PRIVATE ${OPENCV_LINKER_LIBS} ${OPENCV_CPP_SAMPLES_REQUIRED_DEPS})
+ocv_target_link_libraries(${target}pnp_detection PRIVATE ${OPENCV_LINKER_LIBS} ${OPENCV_CPP_SAMPLES_REQUIRED_DEPS})

samples/directx/CMakeLists.txt

@@ -17,5 +17,5 @@ ocv_include_modules_recurse(${tgt} ${OPENCV_DIRECTX_SAMPLES_REQUIRED_DEPS})
 file(GLOB all_samples RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} *.cpp)
 foreach(sample_filename ${all_samples})
   ocv_define_sample(tgt ${sample_filename} directx)
-  ocv_target_link_libraries(${tgt} LINK_PRIVATE ${OPENCV_LINKER_LIBS} ${OPENCV_DIRECTX_SAMPLES_REQUIRED_DEPS})
+  ocv_target_link_libraries(${tgt} PRIVATE ${OPENCV_LINKER_LIBS} ${OPENCV_DIRECTX_SAMPLES_REQUIRED_DEPS})
 endforeach()

samples/dnn/CMakeLists.txt

@@ -18,5 +18,5 @@ ocv_include_modules_recurse(${OPENCV_DNN_SAMPLES_REQUIRED_DEPS})
 file(GLOB_RECURSE dnn_samples RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} *.cpp)
 foreach(sample_filename ${dnn_samples})
   ocv_define_sample(tgt ${sample_filename} dnn)
-  ocv_target_link_libraries(${tgt} LINK_PRIVATE ${OPENCV_LINKER_LIBS} ${OPENCV_DNN_SAMPLES_REQUIRED_DEPS})
+  ocv_target_link_libraries(${tgt} PRIVATE ${OPENCV_LINKER_LIBS} ${OPENCV_DNN_SAMPLES_REQUIRED_DEPS})
 endforeach()

samples/gpu/CMakeLists.txt

@@ -51,11 +51,11 @@ endif()
 file(GLOB all_samples RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} *.cpp)
 foreach(sample_filename ${all_samples})
   ocv_define_sample(tgt ${sample_filename} gpu)
-  ocv_target_link_libraries(${tgt} LINK_PRIVATE ${OPENCV_LINKER_LIBS} ${OPENCV_CUDA_SAMPLES_REQUIRED_DEPS})
+  ocv_target_link_libraries(${tgt} PRIVATE ${OPENCV_LINKER_LIBS} ${OPENCV_CUDA_SAMPLES_REQUIRED_DEPS})
   if(HAVE_opencv_xfeatures2d)
-    ocv_target_link_libraries(${tgt} LINK_PRIVATE opencv_xfeatures2d)
+    ocv_target_link_libraries(${tgt} PRIVATE opencv_xfeatures2d)
   endif()
   if(HAVE_opencv_cudacodec)
-    ocv_target_link_libraries(${tgt} LINK_PRIVATE opencv_cudacodec)
+    ocv_target_link_libraries(${tgt} PRIVATE opencv_cudacodec)
   endif()
 endforeach()

samples/opencl/CMakeLists.txt

@@ -31,7 +31,7 @@ ocv_include_directories(${OpenCL_INCLUDE_DIR})
 file(GLOB all_samples RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} *.cpp)
 foreach(sample_filename ${all_samples})
   ocv_define_sample(tgt ${sample_filename} opencl)
-  ocv_target_link_libraries(${tgt} LINK_PRIVATE
+  ocv_target_link_libraries(${tgt} PRIVATE
     ${OPENCV_LINKER_LIBS}
     ${OPENCV_OPENCL_SAMPLES_REQUIRED_DEPS}
     ${OpenCL_LIBRARY})

samples/opengl/CMakeLists.txt

@@ -23,9 +23,9 @@ if(BUILD_EXAMPLES AND OCV_DEPENDENCIES_FOUND)
   endif()
   foreach(sample_filename ${all_samples})
     ocv_define_sample(tgt ${sample_filename} opengl)
-    ocv_target_link_libraries(${tgt} LINK_PRIVATE ${OPENCV_LINKER_LIBS} ${OPENCV_OPENGL_SAMPLES_REQUIRED_DEPS})
+    ocv_target_link_libraries(${tgt} PRIVATE ${OPENCV_LINKER_LIBS} ${OPENCV_OPENGL_SAMPLES_REQUIRED_DEPS})
     if(sample_filename STREQUAL "opengl_interop.cpp")
-      ocv_target_link_libraries(${tgt} LINK_PRIVATE ${X11_LIBRARIES})
+      ocv_target_link_libraries(${tgt} PRIVATE ${X11_LIBRARIES})
       ocv_target_include_directories(${tgt} ${X11_INCLUDE_DIR})
     endif()
   endforeach()

samples/openvx/CMakeLists.txt

@@ -21,5 +21,5 @@ add_definitions(-DIVX_HIDE_INFO_WARNINGS)
 file(GLOB_RECURSE cpp_samples RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} *.cpp)
 foreach(sample_filename ${cpp_samples})
   ocv_define_sample(tgt ${sample_filename} openvx)
-  ocv_target_link_libraries(${tgt} LINK_PRIVATE ${OPENCV_LINKER_LIBS} ${OPENCV_OPENVX_SAMPLE_REQUIRED_DEPS})
+  ocv_target_link_libraries(${tgt} PRIVATE ${OPENCV_LINKER_LIBS} ${OPENCV_OPENVX_SAMPLE_REQUIRED_DEPS})
 endforeach()

samples/samples_utils.cmake

@@ -6,7 +6,7 @@ function(ocv_define_sample out_target source sub)
   set(the_target "example_${sub}_${name}")
   add_executable(${the_target} "${source}")
   if(TARGET Threads::Threads AND NOT OPENCV_EXAMPLES_DISABLE_THREADS)
-    target_link_libraries(${the_target} LINK_PRIVATE Threads::Threads)
+    target_link_libraries(${the_target} PRIVATE Threads::Threads)
   endif()
   set_target_properties(${the_target} PROPERTIES PROJECT_LABEL "(sample) ${name}")
   if(ENABLE_SOLUTION_FOLDERS)

samples/tapi/CMakeLists.txt

@@ -22,5 +22,5 @@ ocv_include_modules_recurse(${OPENCV_TAPI_SAMPLES_REQUIRED_DEPS})
 file(GLOB all_samples RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} *.cpp)
 foreach(sample_filename ${all_samples})
   ocv_define_sample(tgt ${sample_filename} tapi)
-  ocv_target_link_libraries(${tgt} LINK_PRIVATE ${OPENCV_LINKER_LIBS} ${OPENCV_TAPI_SAMPLES_REQUIRED_DEPS})
+  ocv_target_link_libraries(${tgt} PRIVATE ${OPENCV_LINKER_LIBS} ${OPENCV_TAPI_SAMPLES_REQUIRED_DEPS})
 endforeach()

samples/va_intel/CMakeLists.txt

@@ -17,5 +17,5 @@ ocv_include_modules_recurse(${OPENCV_VA_INTEL_SAMPLES_REQUIRED_DEPS})
 file(GLOB all_samples RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} *.cpp)
 foreach(sample_filename ${all_samples})
   ocv_define_sample(tgt ${sample_filename} va_intel)
-  ocv_target_link_libraries(${tgt} LINK_PRIVATE ${OPENCV_LINKER_LIBS} ${OPENCV_VA_INTEL_SAMPLES_REQUIRED_DEPS} ${VA_LIBRARIES} ${VA_INTEL_LIBRARIES})
+  ocv_target_link_libraries(${tgt} PRIVATE ${OPENCV_LINKER_LIBS} ${OPENCV_VA_INTEL_SAMPLES_REQUIRED_DEPS} ${VA_LIBRARIES} ${VA_INTEL_LIBRARIES})
 endforeach()