Merge pull request #10495 from alalek:cmake_java

CMakeLists.txt

@@ -458,6 +458,14 @@ if(INSTALL_TO_MANGLED_PATHS)
   endforeach()
 endif()
 
+if(ANDROID)
+  ocv_update(OPENCV_JNI_INSTALL_PATH "${OPENCV_LIB_INSTALL_PATH}")
+elseif(INSTALL_CREATE_DISTRIB)
+  ocv_update(OPENCV_JNI_INSTALL_PATH "${OPENCV_JAR_INSTALL_PATH}/${OpenCV_ARCH}")
+else()
+  ocv_update(OPENCV_JNI_INSTALL_PATH "${OPENCV_JAR_INSTALL_PATH}")
+endif()
+ocv_update(OPENCV_JNI_BIN_INSTALL_PATH "${OPENCV_JNI_INSTALL_PATH}")
 
 if(WIN32)
   # Postfix of DLLs:
@@ -608,6 +616,7 @@ include(cmake/OpenCVFindLAPACK.cmake)
 # ----------------------------------------------------------------------------
 
 # --- Doxygen for documentation ---
+add_custom_target(opencv_docs ALL)
 if(BUILD_DOCS)
   find_package(Doxygen)
 else()

cmake/OpenCVDetectAndroidSDK.cmake

@@ -300,7 +300,7 @@ macro(add_android_project target path)
     if(android_proj_IGNORE_JAVA)
       set(android_proj_extra_deps "")
     else()
-      list(APPEND android_proj_extra_deps "${OpenCV_BINARY_DIR}/bin/classes.jar.dephelper" opencv_java)
+      list(APPEND android_proj_extra_deps opencv_java_android)
     endif()
     add_custom_command(
         OUTPUT "${android_proj_bin_dir}/bin/${target}-debug.apk"
@@ -333,10 +333,6 @@ macro(add_android_project target path)
       ocv_copyfiles_add_target(${target}_copy_libs NATIVE_COPY "Copy native libs for project: ${target}" ${_native_deps})
 
       add_dependencies(${target} ${target}_copy_libs)
-
-      if (ANDROID_EXAMPLES_WITH_LIBS)
-        add_dependencies(${target}_copy_libs opencv_java)
-      endif()
     endif()
 
     # There is some strange problem with concurrent Android .APK builds:

cmake/OpenCVModule.cmake

@@ -774,6 +774,9 @@ endmacro()
 #   ocv_create_module()
 macro(ocv_create_module)
   ocv_debug_message("${the_module}: ocv_create_module(" ${ARGN} ")")
+  if(OPENCV_MODULE_${the_module}_CLASS STREQUAL "BINDINGS")
+    message(FATAL_ERROR "Bindings module can't call ocv_create_module()")
+  endif()
   if(NOT " ${ARGN}" STREQUAL " ")
     set(OPENCV_MODULE_${the_module}_LINK_DEPS "${OPENCV_MODULE_${the_module}_LINK_DEPS};${ARGN}" CACHE INTERNAL "")
   endif()

cmake/OpenCVUtils.cmake

@@ -171,28 +171,54 @@ function(ocv_target_include_directories target)
       ";${ARGN};" MATCHES "/usr/include;")
     return() # workaround for GCC 6.x bug
   endif()
+  set(__params "")
+  set(__system_params "")
+  set(__var_name __params)
   foreach(dir ${ARGN})
-    get_filename_component(__abs_dir "${dir}" ABSOLUTE)
-    ocv_is_opencv_directory(__is_opencv_dir "${dir}")
-    if(__is_opencv_dir)
-      list(APPEND __params "${__abs_dir}")
+    if("${dir}" STREQUAL "SYSTEM")
+      set(__var_name __system_params)
     else()
-      list(APPEND __params "${dir}")
+      get_filename_component(__abs_dir "${dir}" ABSOLUTE)
+      ocv_is_opencv_directory(__is_opencv_dir "${dir}")
+      if(__is_opencv_dir)
+        list(APPEND ${__var_name} "${__abs_dir}")
+      else()
+        list(APPEND ${__var_name} "${dir}")
+      endif()
     endif()
   endforeach()
   if(HAVE_CUDA OR CMAKE_VERSION VERSION_LESS 2.8.11)
     include_directories(${__params})
+    include_directories(SYSTEM ${__system_params})
   else()
     if(TARGET ${target})
-      target_include_directories(${target} PRIVATE ${__params})
-      if(OPENCV_DEPENDANT_TARGETS_${target})
-        foreach(t ${OPENCV_DEPENDANT_TARGETS_${target}})
-          target_include_directories(${t} PRIVATE ${__params})
-        endforeach()
+      if(__params)
+        target_include_directories(${target} PRIVATE ${__params})
+        if(OPENCV_DEPENDANT_TARGETS_${target})
+          foreach(t ${OPENCV_DEPENDANT_TARGETS_${target}})
+            target_include_directories(${t} PRIVATE ${__params})
+          endforeach()
+        endif()
+      endif()
+      if(__system_params)
+        target_include_directories(${target} SYSTEM PRIVATE ${__system_params})
+        if(OPENCV_DEPENDANT_TARGETS_${target})
+          foreach(t ${OPENCV_DEPENDANT_TARGETS_${target}})
+            target_include_directories(${t} SYSTEM PRIVATE ${__system_params})
+          endforeach()
+        endif()
       endif()
     else()
-      set(__new_inc "${OCV_TARGET_INCLUDE_DIRS_${target}};${__params}")
-      set(OCV_TARGET_INCLUDE_DIRS_${target} "${__new_inc}" CACHE INTERNAL "")
+      if(__params)
+        set(__new_inc ${OCV_TARGET_INCLUDE_DIRS_${target}})
+        list(APPEND __new_inc ${__params})
+        set(OCV_TARGET_INCLUDE_DIRS_${target} "${__new_inc}" CACHE INTERNAL "")
+      endif()
+      if(__system_params)
+        set(__new_inc ${OCV_TARGET_INCLUDE_SYSTEM_DIRS_${target}})
+        list(APPEND __new_inc ${__system_params})
+        set(OCV_TARGET_INCLUDE_SYSTEM_DIRS_${target} "${__new_inc}" CACHE INTERNAL "")
+      endif()
     endif()
   endif()
 endfunction()
@@ -1078,6 +1104,16 @@ function(_ocv_append_target_includes target)
     endif()
     unset(OCV_TARGET_INCLUDE_DIRS_${target} CACHE)
   endif()
+
+  if(DEFINED OCV_TARGET_INCLUDE_SYSTEM_DIRS_${target})
+    target_include_directories(${target} SYSTEM PRIVATE ${OCV_TARGET_INCLUDE_SYSTEM_DIRS_${target}})
+    if(OPENCV_DEPENDANT_TARGETS_${target})
+      foreach(t ${OPENCV_DEPENDANT_TARGETS_${target}})
+        target_include_directories(${t} SYSTEM PRIVATE ${OCV_TARGET_INCLUDE_SYSTEM_DIRS_${target}})
+      endforeach()
+    endif()
+    unset(OCV_TARGET_INCLUDE_SYSTEM_DIRS_${target} CACHE)
+  endif()
 endfunction()
 
 function(ocv_add_executable target)

doc/CMakeLists.txt

@@ -33,7 +33,7 @@ endif(HAVE_DOC_GENERATOR)
 
 if(BUILD_DOCS AND DOXYGEN_FOUND)
   # not documented modules list
-  list(APPEND blacklist "ts" "java" "python_bindings_generator" "python2" "python3" "js" "world")
+  list(APPEND blacklist "ts" "java_bindings_generator" "java" "python_bindings_generator" "python2" "python3" "js" "world")
   unset(CMAKE_DOXYGEN_TUTORIAL_CONTRIB_ROOT)
   unset(CMAKE_DOXYGEN_TUTORIAL_JS_ROOT)
 
@@ -252,4 +252,6 @@ if(BUILD_DOCS AND DOXYGEN_FOUND)
       DEPENDS doxygen
       COMMAND "${CMAKE_COMMAND}" -DCMAKE_INSTALL_COMPONENT=docs -P "${CMAKE_BINARY_DIR}/cmake_install.cmake"
   )
+
+  add_dependencies(opencv_docs doxygen)
 endif()

modules/core/misc/java/gen_dict.json

 {
+    "module_imports": [ "java.lang.String" ],
+    "module_j_code": "src/java/core+Core.jcode.in",
     "class_ignore_list" : [
         "FileNode",
         "FileStorage",

modules/core/misc/java/src/java/core+Core.jcode.in

+    // these constants are wrapped inside functions to prevent inlining
+    private static String getVersion() { return "@OPENCV_VERSION@"; }
+    private static String getNativeLibraryName() { return "opencv_java@OPENCV_VERSION_MAJOR@@OPENCV_VERSION_MINOR@@OPENCV_VERSION_PATCH@"; }
+    private static int getVersionMajor() { return @OPENCV_VERSION_MAJOR@; }
+    private static int getVersionMinor() { return @OPENCV_VERSION_MINOR@; }
+    private static int getVersionRevision() { return @OPENCV_VERSION_PATCH@; }
+    private static String getVersionStatus() { return "@OPENCV_VERSION_STATUS@"; }
+
+    public static final String VERSION = getVersion();
+    public static final String NATIVE_LIBRARY_NAME = getNativeLibraryName();
+    public static final int VERSION_MAJOR = getVersionMajor();
+    public static final int VERSION_MINOR = getVersionMinor();
+    public static final int VERSION_REVISION = getVersionRevision();
+    public static final String VERSION_STATUS = getVersionStatus();

modules/dnn/misc/java/src/cpp/dnn_converters.hpp

@@ -8,7 +8,7 @@
 #define	DNN_CONVERTERS_HPP
 
 #include <jni.h>
-#include "opencv2/java.hpp"
+#include "opencv_java.hpp"
 #include "opencv2/core.hpp"
 #include "opencv2/dnn/dnn.hpp"
 

modules/highgui/misc/java/gen_dict.json

-{
-    "const_ignore_list": [
-        "EVENT_.*",
-        "WINDOW_AUTOSIZE",
-        "CV_WND_PROP_",
-        "CV_WINDOW_",
-        "CV_EVENT_",
-        "CV_GUI_",
-        "CV_PUSH_BUTTON",
-        "CV_CHECKBOX",
-        "CV_RADIOBOX",
-        "WINDOW_.+",
-        "WND_PROP_.+"
-    ],
-    "ManualFuncs" : {
-        "Highgui" : {
-            "namedWindow"       : {"j_code" : [""], "jn_code" : [""], "cpp_code" : [""] },
-            "destroyWindow"     : {"j_code" : [""], "jn_code" : [""], "cpp_code" : [""] },
-            "destroyAllWindows" : {"j_code" : [""], "jn_code" : [""], "cpp_code" : [""] },
-            "startWindowThread" : {"j_code" : [""], "jn_code" : [""], "cpp_code" : [""] },
-            "setWindowProperty" : {"j_code" : [""], "jn_code" : [""], "cpp_code" : [""] },
-            "getWindowProperty" : {"j_code" : [""], "jn_code" : [""], "cpp_code" : [""] },
-            "getTrackbarPos"    : {"j_code" : [""], "jn_code" : [""], "cpp_code" : [""] },
-            "setTrackbarPos"    : {"j_code" : [""], "jn_code" : [""], "cpp_code" : [""] },
-            "imshow"            : {"j_code" : [""], "jn_code" : [""], "cpp_code" : [""] },
-            "waitKey"           : {"j_code" : [""], "jn_code" : [""], "cpp_code" : [""] },
-            "moveWindow"        : {"j_code" : [""], "jn_code" : [""], "cpp_code" : [""] },
-            "resizeWindow"      : {"j_code" : [""], "jn_code" : [""], "cpp_code" : [""] }
-        }
-    }
-}

modules/imgcodecs/misc/java/test/HighguiTest.java → modules/imgcodecs/misc/java/test/ImgcodecsTest.java

-package org.opencv.test.highgui;
+package org.opencv.test.imgcodecs;
 
 import org.opencv.core.MatOfByte;
 import org.opencv.core.MatOfInt;
@@ -6,7 +6,7 @@ import org.opencv.imgcodecs.Imgcodecs;
 import org.opencv.test.OpenCVTestCase;
 import org.opencv.test.OpenCVTestRunner;
 
-public class HighguiTest extends OpenCVTestCase {
+public class ImgcodecsTest extends OpenCVTestCase {
 
     public void testImdecode() {
         fail("Not yet implemented");

modules/java/android_lib/jni/Android.mk

-LOCAL_PATH := $(call my-dir)
-
-include $(CLEAR_VARS)
-
-include OpenCV.mk
-
-LOCAL_MODULE    := opencv_java
-
-MY_PREFIX := $(LOCAL_PATH)
-MY_SOURCES := $(wildcard $(MY_PREFIX)/*.cpp)
-LOCAL_SRC_FILES := $(MY_SOURCES:$(MY_PREFIX)%=%)
-
-LOCAL_LDLIBS +=  -llog -ldl -ljnigraphics
-
-include $(BUILD_SHARED_LIBRARY)

modules/java/android_lib/jni/Application.mk

-APP_STL := gnustl_static
-APP_CPPFLAGS := -frtti -fexceptions
-APP_ABI := armeabi-v7a

modules/java/android_sdk/CMakeLists.txt

+if(NOT ANDROID_EXECUTABLE)
+  message(WARNING "'android' tool required to build Android SDK")
+  return()
+endif()
+ocv_assert(ANDROID_TOOLS_Pkg_Revision GREATER 13)
+
+project(${the_module}_android)
+
+set(OPENCV_JAVA_DIR "${OpenCV_BINARY_DIR}/android_sdk" CACHE INTERNAL "")
+set(OPENCV_ANDROID_LIB_DIR "${OPENCV_JAVA_DIR}" CACHE INTERNAL "")  # for OpenCV samples
+
+file(REMOVE_RECURSE "${OPENCV_JAVA_DIR}")
+file(MAKE_DIRECTORY "${OPENCV_JAVA_DIR}/bin")
+set(java_src_dir "${OPENCV_JAVA_DIR}/src")
+file(MAKE_DIRECTORY "${java_src_dir}")
+
+ocv_copyfiles_append_dir(JAVA_SRC_COPY "${OPENCV_JAVA_BINDINGS_DIR}/gen/java" "${java_src_dir}")
+ocv_copyfiles_append_dir(JAVA_SRC_COPY "${OPENCV_JAVA_BINDINGS_DIR}/gen/android/java" "${java_src_dir}")
+
+# calc default SDK Target
+android_get_compatible_target(android_sdk_target ${ANDROID_NATIVE_API_LEVEL} ${ANDROID_SDK_TARGET} 14)
+string(REGEX REPLACE "android-" "" android_sdk_target_num ${android_sdk_target})
+if( (ANDROID_SDK_TARGET AND ANDROID_SDK_TARGET LESS 21) OR (android_sdk_target_num LESS 21) )
+  message(STATUS "[OpenCV for Android SDK]: A new OpenGL Camera Bridge (CameraGLSurfaceView, CameraGLRendererBase, CameraRenderer, Camera2Renderer) is disabled, because ANDROID_SDK_TARGET (${android_sdk_target_num}) < 21")
+else()
+  ocv_copyfiles_append_dir(JAVA_SRC_COPY "${OPENCV_JAVA_BINDINGS_DIR}/gen/android-21/java" "${java_src_dir}")
+endif()
+
+# copy boilerplate
+file(GLOB_RECURSE seed_project_files_rel RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}/android_lib/" "${CMAKE_CURRENT_SOURCE_DIR}/android_lib/*")
+list(REMOVE_ITEM seed_project_files_rel "${ANDROID_MANIFEST_FILE}")
+foreach(file ${seed_project_files_rel})
+  configure_file("${CMAKE_CURRENT_SOURCE_DIR}/android_lib/${file}" "${OPENCV_JAVA_DIR}/${file}" @ONLY)
+  list(APPEND depends "${CMAKE_CURRENT_SOURCE_DIR}/android_lib/${file}")
+  get_filename_component(install_subdir "${file}" PATH)
+  install(FILES "${OPENCV_JAVA_DIR}/${file}" DESTINATION "${JAVA_INSTALL_ROOT}/${install_subdir}" COMPONENT java)
+endforeach()
+
+list(APPEND depends gen_opencv_java_source "${OPENCV_DEPHELPER}/gen_opencv_java_source")
+ocv_copyfiles_add_target(${the_module}_android_source_copy JAVA_SRC_COPY "Copy Java(Andoid SDK) source files" ${depends})
+file(REMOVE "${OPENCV_DEPHELPER}/${the_module}_android_source_copy")  # force rebuild after CMake run
+
+set(depends ${the_module}_android_source_copy "${OPENCV_DEPHELPER}/${the_module}_android_source_copy")
+
+# generate Android library project
+set(android_sdk_project_files ${ANDROID_LIB_PROJECT_FILES})  # build.xml;local.properties;proguard-project.txt;project.properties
+ocv_list_add_prefix(android_sdk_project_files "${OPENCV_JAVA_DIR}/")
+
+configure_file("${CMAKE_CURRENT_SOURCE_DIR}/android_lib/${ANDROID_MANIFEST_FILE}" "${CMAKE_CURRENT_BINARY_DIR}/${ANDROID_MANIFEST_FILE}" @ONLY)
+
+add_custom_command(
+    OUTPUT ${android_sdk_project_files} "${OPENCV_JAVA_DIR}/${ANDROID_MANIFEST_FILE}"
+    COMMAND ${CMAKE_COMMAND} -E remove ${android_sdk_project_files}
+    COMMAND ${CMAKE_COMMAND} -E copy_if_different "${CMAKE_CURRENT_BINARY_DIR}/${ANDROID_MANIFEST_FILE}" "${OPENCV_JAVA_DIR}/${ANDROID_MANIFEST_FILE}"
+    COMMAND ${ANDROID_EXECUTABLE} --silent create lib-project --path \"${OPENCV_JAVA_DIR}\" --target \"${android_sdk_target}\" --name OpenCV --package org.opencv 2>\"${CMAKE_CURRENT_BINARY_DIR}/create_lib_project.log\"
+    COMMAND ${CMAKE_COMMAND} -E copy_if_different "${CMAKE_CURRENT_BINARY_DIR}/${ANDROID_MANIFEST_FILE}" "${OPENCV_JAVA_DIR}/${ANDROID_MANIFEST_FILE}"
+    WORKING_DIRECTORY "${OPENCV_JAVA_DIR}"
+    MAIN_DEPENDENCY "${CMAKE_CURRENT_BINARY_DIR}/${ANDROID_MANIFEST_FILE}"
+    DEPENDS ${depends}
+    COMMENT "Generating OpenCV Android library project. SDK target: ${lib_target_sdk_target}"
+)
+list(APPEND depends ${android_sdk_project_files} "${OPENCV_JAVA_DIR}/${ANDROID_MANIFEST_FILE}")
+
+install(DIRECTORY "${OPENCV_JAVA_DIR}/src" DESTINATION "${JAVA_INSTALL_ROOT}" COMPONENT java)
+install(FILES "${OPENCV_JAVA_DIR}/${ANDROID_PROJECT_PROPERTIES_FILE}" DESTINATION ${JAVA_INSTALL_ROOT} COMPONENT java)
+install(FILES "${OPENCV_JAVA_DIR}/${ANDROID_MANIFEST_FILE}" DESTINATION ${JAVA_INSTALL_ROOT} COMPONENT java)
+
+# build jar
+set(JAR_FILE "${OpenCV_BINARY_DIR}/bin/classes.jar")
+# build the library project
+# normally we should do this after a native part, but for a library project we can build the java part first
+add_custom_command(
+    OUTPUT "${JAR_FILE}" "${OPENCV_DEPHELPER}/${the_module}_android"
+    COMMAND ${ANT_EXECUTABLE} -q -noinput -k debug -Djava.target=1.6 -Djava.source=1.6
+    COMMAND ${CMAKE_COMMAND} -E touch "${OPENCV_DEPHELPER}/${the_module}_android"
+    WORKING_DIRECTORY "${OPENCV_JAVA_DIR}"
+    DEPENDS ${depends}
+    COMMENT "Building OpenCV Android library project"
+)
+
+add_custom_target(${the_module}_android DEPENDS "${OPENCV_DEPHELPER}/${the_module}_android" SOURCES "${CMAKE_CURRENT_SOURCE_DIR}/android_lib/${ANDROID_MANIFEST_FILE}")
+add_dependencies(${the_module} ${the_module}_android)
+
+# empty 'gen' and 'res' folders
+install(CODE "
+FILE(MAKE_DIRECTORY \"\$ENV{DESTDIR}\${CMAKE_INSTALL_PREFIX}/${JAVA_INSTALL_ROOT}/gen\")
+FILE(MAKE_DIRECTORY \"\$ENV{DESTDIR}\${CMAKE_INSTALL_PREFIX}/${JAVA_INSTALL_ROOT}/res\")
+" COMPONENT java)

modules/java/common.cmake

+if(ANDROID)
+  ocv_update(OPENCV_JAVA_LIB_NAME_SUFFIX "${OPENCV_VERSION_MAJOR}")
+  ocv_update(JAVA_INSTALL_ROOT "sdk/java")
+else()
+  ocv_update(OPENCV_JAVA_LIB_NAME_SUFFIX "${OPENCV_VERSION_MAJOR}${OPENCV_VERSION_MINOR}${OPENCV_VERSION_PATCH}")
+endif()
+
+# get list of modules to wrap
+# message(STATUS "Wrapped in java:")
+set(OPENCV_JAVA_MODULES)
+foreach(m ${OPENCV_MODULES_BUILD})
+  if (";${OPENCV_MODULE_${m}_WRAPPERS};" MATCHES ";java;" AND HAVE_${m})
+    list(APPEND OPENCV_JAVA_MODULES ${m})
+    #message(STATUS "\t${m}")
+  endif()
+endforeach()

modules/java/generator/CMakeLists.txt

+set(MODULE_NAME "java_bindings_generator")
+set(OPENCV_MODULE_IS_PART_OF_WORLD FALSE)
+ocv_add_module(${MODULE_NAME} INTERNAL)
+
+set(OPENCV_JAVA_SIGNATURES_FILE "${CMAKE_CURRENT_BINARY_DIR}/opencv_java_signatures.json" CACHE INTERNAL "")
+set(OPENCV_JAVA_BINDINGS_DIR "${CMAKE_CURRENT_BINARY_DIR}" CACHE INTERNAL "")
+
+file(REMOVE_RECURSE "${OPENCV_JAVA_BINDINGS_DIR}/gen")
+file(REMOVE "${OPENCV_DEPHELPER}/gen_opencv_java_source")  # force re-run after CMake
+
+# This file is included from a subdirectory
+set(JAVA_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/..")
+include(${JAVA_SOURCE_DIR}/common.cmake)
+
+set(__remap_config "") # list of remapped ".in" files (configure_file)
+set(__remap_targets "")
+
+macro(ocv_remap_files files_list_var)
+  set(target_dir "${OpenCV_BINARY_DIR}/configured")
+  foreach(f ${${files_list_var}})
+    if(NOT "${f}" MATCHES "^(.*)\\.in$")
+      #continue()  # since CMake 3.2+
+    else()
+    set(f_ "${CMAKE_MATCH_1}")
+    file(RELATIVE_PATH rel_path0 "${OpenCV_SOURCE_DIR}" "${f}")
+    file(RELATIVE_PATH rel_path1 "${OpenCV_SOURCE_DIR}" "${f_}")
+    set(__target_file "${target_dir}/${rel_path1}")
+    configure_file("${f}" "${__target_file}" @ONLY)
+    if(__remap_config)
+      set(__remap_config "${__remap_config},\n")
+    endif()
+    set(__remap_config "${__remap_config}    { \"src\": \"${rel_path0}\", \"target\": \"${__target_file}\" }")
+    list(APPEND __remap_targets "${__target_file}")
+    endif()
+  endforeach()
+endmacro()
+
+# common files
+file(GLOB_RECURSE deps "${CMAKE_CURRENT_SOURCE_DIR}/src/*" "${CMAKE_CURRENT_SOURCE_DIR}/android*/*" "${CMAKE_CURRENT_SOURCE_DIR}/templates/*")
+ocv_remap_files(deps)
+
+set(__modules_config "") # list of OpenCV modules
+foreach(m ${OPENCV_JAVA_MODULES})
+  set(module_java_dir "${OPENCV_MODULE_${m}_LOCATION}/misc/java")
+  list(APPEND deps ${OPENCV_MODULE_${m}_HEADERS})
+  file(GLOB_RECURSE misc_files "${module_java_dir}/*")
+  list(APPEND deps ${misc_files})
+
+  string(REGEX REPLACE "^opencv_" "" m_ "${m}")
+  if(__modules_config)
+    set(__modules_config "${__modules_config},\n")
+  endif()
+  file(RELATIVE_PATH rel_path "${OpenCV_SOURCE_DIR}" "${OPENCV_MODULE_${m}_LOCATION}")
+  set(__modules_config "${__modules_config}    { \"name\": \"${m_}\", \"location\": \"${rel_path}\" }")
+
+  ocv_remap_files(misc_files)
+endforeach(m)
+
+set(CONFIG_FILE "${CMAKE_CURRENT_BINARY_DIR}/gen_java.json")
+set(__config_str
+"{
+  \"rootdir\": \"${OpenCV_SOURCE_DIR}\",
+  \"modules\": [
+${__modules_config}
+  ],
+  \"files_remap\": [
+${__remap_config}
+  ]
+}
+")
+if(EXISTS "${CONFIG_FILE}")
+  file(READ "${CONFIG_FILE}" __content)
+else()
+  set(__content "")
+endif()
+if(NOT "${__content}" STREQUAL "${__config_str}")
+  file(WRITE "${CONFIG_FILE}" "${__config_str}")
+  file(REMOVE "${OPENCV_DEPHELPER}/gen_opencv_java_source")
+endif()
+unset(__config_str)
+
+set(java_generated_files
+    # "${OPENCV_JAVA_SIGNATURES_FILE}"
+    "${OPENCV_DEPHELPER}/gen_opencv_java_source"
+)
+
+add_custom_command(
+    OUTPUT ${java_generated_files}
+    COMMAND ${PYTHON_DEFAULT_EXECUTABLE} "${JAVA_SOURCE_DIR}/generator/gen_java.py" -p "${JAVA_SOURCE_DIR}/../python/src2/gen2.py" -c "${CONFIG_FILE}"
+    COMMAND ${CMAKE_COMMAND} -E touch "${OPENCV_DEPHELPER}/gen_opencv_java_source"
+    WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}"
+    DEPENDS "${JAVA_SOURCE_DIR}/generator/gen_java.py"
+            "${JAVA_SOURCE_DIR}/../python/src2/gen2.py"
+            "${JAVA_SOURCE_DIR}/../python/src2/hdr_parser.py"
+            # don't, result of file(WRITE): "${CMAKE_CURRENT_BINARY_DIR}/gen_java.json"
+            ${deps} ${__remap_targets}
+            # not allowed (file(WRITE) result): "${CONFIG_FILE}"
+    COMMENT "Generate files for Java bindings"
+)
+
+add_custom_target(gen_opencv_java_source DEPENDS ${java_generated_files}
+    SOURCES "${JAVA_SOURCE_DIR}/generator/gen_java.py"
+            "${CMAKE_CURRENT_BINARY_DIR}/gen_java.json"
+)

modules/java/generator/src/cpp/Mat.cpp

-#define LOG_TAG "org.opencv.core.Mat"
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
 
-#include <stdexcept>
-#include <string>
+#include "opencv2/core.hpp"
 
+#define LOG_TAG "org.opencv.core.Mat"
 #include "common.h"
-#include "opencv2/core.hpp"
 
 using namespace cv;
 
@@ -1777,67 +1778,6 @@ JNIEXPORT void JNICALL Java_org_opencv_core_Mat_n_1delete
     delete (Mat*) self;
 }
 
-// unlike other nPut()-s this one (with double[]) should convert input values to correct type
-#define PUT_ITEM(T, R, C) { T*dst = (T*)me->ptr(R, C); for(int ch=0; ch<me->channels() && count>0; count--,ch++,src++,dst++) *dst = cv::saturate_cast<T>(*src); }
-
-JNIEXPORT jint JNICALL Java_org_opencv_core_Mat_nPutD
-    (JNIEnv* env, jclass, jlong self, jint row, jint col, jint count, jdoubleArray vals);
-
-JNIEXPORT jint JNICALL Java_org_opencv_core_Mat_nPutD
-    (JNIEnv* env, jclass, jlong self, jint row, jint col, jint count, jdoubleArray vals)
-{
-    static const char method_name[] = "Mat::nPutD()";
-    try {
-        LOGD("%s", method_name);
-        cv::Mat* me = (cv::Mat*) self;
-        if(!me || !me->data) return 0;  // no native object behind
-        if(me->rows<=row || me->cols<=col) return 0; // indexes out of range
-
-        int rest = ((me->rows - row) * me->cols - col) * me->channels();
-        if(count>rest) count = rest;
-        int res = count;
-        double* values = (double*)env->GetPrimitiveArrayCritical(vals, 0);
-        double* src = values;
-        int r, c;
-        for(c=col; c<me->cols && count>0; c++)
-        {
-            switch(me->depth()) {
-                case CV_8U:  PUT_ITEM(uchar,  row, c); break;
-                case CV_8S:  PUT_ITEM(schar,  row, c); break;
-                case CV_16U: PUT_ITEM(ushort, row, c); break;
-                case CV_16S: PUT_ITEM(short,  row, c); break;
-                case CV_32S: PUT_ITEM(int,    row, c); break;
-                case CV_32F: PUT_ITEM(float,  row, c); break;
-                case CV_64F: PUT_ITEM(double, row, c); break;
-            }
-        }
-
-        for(r=row+1; r<me->rows && count>0; r++)
-            for(c=0; c<me->cols && count>0; c++)
-            {
-                switch(me->depth()) {
-                    case CV_8U:  PUT_ITEM(uchar,  r, c); break;
-                    case CV_8S:  PUT_ITEM(schar,  r, c); break;
-                    case CV_16U: PUT_ITEM(ushort, r, c); break;
-                    case CV_16S: PUT_ITEM(short,  r, c); break;
-                    case CV_32S: PUT_ITEM(int,    r, c); break;
-                    case CV_32F: PUT_ITEM(float,  r, c); break;
-                    case CV_64F: PUT_ITEM(double, r, c); break;
-                }
-            }
-
-        env->ReleasePrimitiveArrayCritical(vals, values, 0);
-        return res;
-    } catch(const std::exception &e) {
-        throwJavaException(env, &e, method_name);
-    } catch (...) {
-        throwJavaException(env, 0, method_name);
-    }
-
-    return 0;
-}
-
-
 } // extern "C"
 
 namespace {
@@ -1963,6 +1903,66 @@ JNIEXPORT jint JNICALL Java_org_opencv_core_Mat_nPutF
   return java_mat_put(env, self, row, col, count, 0, vals);
 }
 
+// unlike other nPut()-s this one (with double[]) should convert input values to correct type
+#define PUT_ITEM(T, R, C) { T*dst = (T*)me->ptr(R, C); for(int ch=0; ch<me->channels() && count>0; count--,ch++,src++,dst++) *dst = cv::saturate_cast<T>(*src); }
+
+JNIEXPORT jint JNICALL Java_org_opencv_core_Mat_nPutD
+    (JNIEnv* env, jclass, jlong self, jint row, jint col, jint count, jdoubleArray vals);
+
+JNIEXPORT jint JNICALL Java_org_opencv_core_Mat_nPutD
+    (JNIEnv* env, jclass, jlong self, jint row, jint col, jint count, jdoubleArray vals)
+{
+    static const char* method_name = JavaOpenCVTrait<jdoubleArray>::put;
+    try {
+        LOGD("%s", method_name);
+        cv::Mat* me = (cv::Mat*) self;
+        if(!me || !me->data) return 0;  // no native object behind
+        if(me->rows<=row || me->cols<=col) return 0; // indexes out of range
+
+        int rest = ((me->rows - row) * me->cols - col) * me->channels();
+        if(count>rest) count = rest;
+        int res = count;
+        double* values = (double*)env->GetPrimitiveArrayCritical(vals, 0);
+        double* src = values;
+        int r, c;
+        for(c=col; c<me->cols && count>0; c++)
+        {
+            switch(me->depth()) {
+                case CV_8U:  PUT_ITEM(uchar,  row, c); break;
+                case CV_8S:  PUT_ITEM(schar,  row, c); break;
+                case CV_16U: PUT_ITEM(ushort, row, c); break;
+                case CV_16S: PUT_ITEM(short,  row, c); break;
+                case CV_32S: PUT_ITEM(int,    row, c); break;
+                case CV_32F: PUT_ITEM(float,  row, c); break;
+                case CV_64F: PUT_ITEM(double, row, c); break;
+            }
+        }
+
+        for(r=row+1; r<me->rows && count>0; r++)
+            for(c=0; c<me->cols && count>0; c++)
+            {
+                switch(me->depth()) {
+                    case CV_8U:  PUT_ITEM(uchar,  r, c); break;
+                    case CV_8S:  PUT_ITEM(schar,  r, c); break;
+                    case CV_16U: PUT_ITEM(ushort, r, c); break;
+                    case CV_16S: PUT_ITEM(short,  r, c); break;
+                    case CV_32S: PUT_ITEM(int,    r, c); break;
+                    case CV_32F: PUT_ITEM(float,  r, c); break;
+                    case CV_64F: PUT_ITEM(double, r, c); break;
+                }
+            }
+
+        env->ReleasePrimitiveArrayCritical(vals, values, 0);
+        return res;
+    } catch(const std::exception &e) {
+        throwJavaException(env, &e, method_name);
+    } catch (...) {
+        throwJavaException(env, 0, method_name);
+    }
+
+    return 0;
+}
+
 } // extern "C"
 
 template<typename T> static int mat_get(cv::Mat* m, int row, int col, int count, char* buff)

modules/java/generator/src/cpp/common.h

-#ifndef __JAVA_COMMON_H__
-#define __JAVA_COMMON_H__
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+
+#ifndef __OPENCV_JAVA_COMMON_H__
+#define __OPENCV_JAVA_COMMON_H__
+
+#include <stdexcept>
+#include <string>
+
+extern "C" {
 
 #if !defined(__ppc__)
 // to suppress warning from jni.h on OS X
@@ -7,7 +16,9 @@
 #endif
 #include <jni.h>
 
-#include "opencv2/java.hpp"
+} // extern "C"
+
+#include "opencv_java.hpp"
 #include "opencv2/core/utility.hpp"
 
 #include "converters.h"
@@ -17,4 +28,4 @@
 #  pragma warning(disable:4800 4244)
 #endif
 
-#endif //__JAVA_COMMON_H__
+#endif //__OPENCV_JAVA_COMMON_H__

modules/java/generator/src/cpp/converters.cpp

+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+
 #define LOG_TAG "org.opencv.utils.Converters"
 #include "common.h"
 

modules/java/generator/src/cpp/converters.h

+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+
 #include "opencv2/opencv_modules.hpp"
 #include "opencv2/core.hpp"
 

modules/java/generator/src/cpp/jni_part.cpp

+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+
 #include "common.h"
 
 #include "opencv2/opencv_modules.hpp"

modules/java/generator/src/cpp/opencv_java.cpp

+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+
+#include "common.h"
+
+// Include all generated JNI code
+#include "opencv_jni.hpp"

modules/java/include/opencv2/java.hpp → modules/java/generator/src/cpp/opencv_java.hpp

@@ -4,9 +4,8 @@
 
 // Author: abratchik
 
-#ifndef JAVA_HPP
-#define	JAVA_HPP
-
+#undef LOGE
+#undef LOGD
 #ifdef __ANDROID__
 #  include <android/log.h>
 #  define LOGE(...) ((void)__android_log_print(ANDROID_LOG_ERROR, LOG_TAG, __VA_ARGS__))
@@ -20,6 +19,8 @@
 #  define LOGD(...)
 #endif
 
+#ifndef OPENCV_JAVA_HPP
+#define	OPENCV_JAVA_HPP
 
 #define MATOFINT(ENV) static_cast<jclass>(ENV->NewGlobalRef(ENV->FindClass("org/opencv/core/MatOfInt")))
 #define GETNATIVEOBJ(ENV, CLS, MAT) ENV->GetLongField(MAT, ENV->GetFieldID(CLS, "nativeObj", "J"))
@@ -34,16 +35,4 @@
 
 #define CHECK_MAT(cond) if(!(cond)){ LOGD("FAILED: " #cond); return; }
 
-
-#ifdef	__cplusplus
-extern "C" {
-#endif
-
-
-
-
-#ifdef	__cplusplus
-}
-#endif
-
-#endif	/* JAVA_HPP */
+#endif	// OPENCV_JAVA_HPP
\ No newline at end of file

modules/java/generator/src/cpp/utils.cpp

-#define LOG_TAG "org.opencv.android.Utils"
-#include "common.h"
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
 
 #include "opencv2/core.hpp"
 #include "opencv2/imgproc.hpp"
@@ -7,6 +8,9 @@
 #ifdef __ANDROID__
 #include <android/bitmap.h>
 
+#define LOG_TAG "org.opencv.android.Utils"
+#include "common.h"
+
 using namespace cv;
 
 extern "C" {

modules/java/generator/src/java/osgi+OpenCVNativeLoader.java.in → modules/java/generator/src/java/org/opencv/osgi/OpenCVNativeLoader.java.in

@@ -12,7 +12,7 @@ import java.util.logging.Logger;
 public class OpenCVNativeLoader implements OpenCVInterface {
 
     public void init() {
-        System.loadLibrary("opencv_java@LIB_NAME_SUFIX@");
+        System.loadLibrary("opencv_java@OPENCV_JAVA_LIB_NAME_SUFFIX@");
         Logger.getLogger("org.opencv.osgi").log(Level.INFO, "Successfully loaded OpenCV native library.");
     }
 }

modules/java/generator/templates/cpp_module.template

+//
+// This file is auto-generated. Please don't modify it!
+//
+
+#undef LOG_TAG
+
+#include "opencv2/opencv_modules.hpp"
+#ifdef HAVE_OPENCV_$M
+
+#include <string>
+
+#include "opencv2/$m.hpp"
+
+$includes
+
+#define LOG_TAG "org.opencv.$m"
+#include "common.h"
+
+using namespace cv;
+
+/// throw java exception
+#undef throwJavaException
+#define throwJavaException throwJavaException_$m
+static void throwJavaException(JNIEnv *env, const std::exception *e, const char *method) {
+  std::string what = "unknown exception";
+  jclass je = 0;
+
+  if(e) {
+    std::string exception_type = "std::exception";
+
+    if(dynamic_cast<const cv::Exception*>(e)) {
+      exception_type = "cv::Exception";
+      je = env->FindClass("org/opencv/core/CvException");
+    }
+
+    what = exception_type + ": " + e->what();
+  }
+
+  if(!je) je = env->FindClass("java/lang/Exception");
+  env->ThrowNew(je, what.c_str());
+
+  LOGE("%s caught %s", method, what.c_str());
+  (void)method;        // avoid "unused" warning
+}
+
+extern "C" {
+
+$code
+
+} // extern "C"
+
+#endif // HAVE_OPENCV_$M

modules/java/generator/templates/java_class.prolog

+//
+// This file is auto-generated. Please don't modify it!
+//
+package org.opencv.$module;
+
+$imports
+
+$docs
+$annotation
+public class $jname {
+
+    protected final long nativeObj;
+    protected $jname(long addr) { nativeObj = addr; }
+
+    public long getNativeObjAddr() { return nativeObj; }
+
+    // internal usage only
+    public static $jname __fromPtr__(long addr) { return new $jname(addr); }

modules/java/generator/templates/java_class_inherited.prolog

+//
+// This file is auto-generated. Please don't modify it!
+//
+package org.opencv.$module;
+
+$imports
+
+$docs
+$annotation
+public class $jname extends $base {
+
+    protected $jname(long addr) { super(addr); }
+
+    // internal usage only
+    public static $jname __fromPtr__(long addr) { return new $jname(addr); }

modules/java/generator/templates/java_module.prolog

+//
+// This file is auto-generated. Please don't modify it!
+//
+package org.opencv.$module;
+
+$imports
+
+$docs
+$annotation
+public class $jname {

modules/java/jar/CMakeLists.txt

+project(${the_module}_jar)
+
+set(OPENCV_JAVA_DIR "${CMAKE_CURRENT_BINARY_DIR}/opencv" CACHE INTERNAL "")
+
+file(REMOVE_RECURSE "${OPENCV_JAVA_DIR}")
+file(REMOVE "${OPENCV_DEPHELPER}/${the_module}_jar_source_copy")
+
+file(MAKE_DIRECTORY "${OPENCV_JAVA_DIR}/build/classes")
+set(java_src_dir "${OPENCV_JAVA_DIR}/java")
+file(MAKE_DIRECTORY "${java_src_dir}")
+
+set(JAR_NAME opencv-${OPENCV_JAVA_LIB_NAME_SUFFIX}.jar)
+set(OPENCV_JAR_FILE "${OpenCV_BINARY_DIR}/bin/${JAR_NAME}" CACHE INTERNAL "")
+
+ocv_copyfiles_append_dir(JAVA_SRC_COPY "${OPENCV_JAVA_BINDINGS_DIR}/gen/java" "${java_src_dir}")
+
+set(depends gen_opencv_java_source "${OPENCV_DEPHELPER}/gen_opencv_java_source")
+ocv_copyfiles_add_target(${the_module}_jar_source_copy JAVA_SRC_COPY "Copy Java(JAR) source files" ${depends})
+set(depends ${the_module}_jar_source_copy "${OPENCV_DEPHELPER}/${the_module}_jar_source_copy")
+
+configure_file("${CMAKE_CURRENT_SOURCE_DIR}/build.xml.in" "${OPENCV_JAVA_DIR}/build.xml" @ONLY)
+list(APPEND depends "${OPENCV_JAVA_DIR}/build.xml")
+
+add_custom_command(OUTPUT "${OPENCV_DEPHELPER}/${the_module}_jar"
+    COMMAND ${ANT_EXECUTABLE} -noinput -k jar
+    COMMAND ${CMAKE_COMMAND} -E touch "${OPENCV_DEPHELPER}/${the_module}_jar"
+    WORKING_DIRECTORY "${OPENCV_JAVA_DIR}"
+    DEPENDS ${depends}
+    COMMENT "Generating ${JAR_NAME}"
+)
+add_custom_target(${the_module}_jar DEPENDS "${OPENCV_DEPHELPER}/${the_module}_jar")
+
+add_custom_command(OUTPUT "${OPENCV_DEPHELPER}/${the_module}doc"
+    COMMAND ${ANT_EXECUTABLE} -noinput -k javadoc
+    COMMAND ${CMAKE_COMMAND} -E touch "${OPENCV_DEPHELPER}/${the_module}doc"
+    WORKING_DIRECTORY "${OPENCV_JAVA_DIR}"
+    DEPENDS ${depends}
+    COMMENT "Generating Javadoc"
+)
+add_custom_target(${the_module}doc DEPENDS "${OPENCV_DEPHELPER}/${the_module}doc")
+
+install(FILES ${OPENCV_JAR_FILE} OPTIONAL DESTINATION ${OPENCV_JAR_INSTALL_PATH} COMPONENT java)
+
+add_dependencies(${the_module} ${the_module}_jar)
+
+if(BUILD_DOCS)
+  add_dependencies(opencv_docs ${the_module}doc)
+
+  install(DIRECTORY ${OpenCV_BINARY_DIR}/doc/javadoc
+    DESTINATION "${OPENCV_DOC_INSTALL_PATH}/javadoc"
+    COMPONENT "docs" OPTIONAL
+  )
+endif()

modules/java/build.xml.in → modules/java/jar/build.xml.in

@@ -3,28 +3,39 @@
 <!-- interface files into OpenCV.jar -->
 <project name="OpenCV">
 
+    <tstamp>
+      <format property="timestamp" pattern="EEE MMM d yyyy HH:mm:ss z"/>
+    </tstamp>
+
   <target name="jar">
     <!-- This is to make a jar with a source attachment, for e.g. easy -->
     <!-- navigation in Eclipse. See this question: -->
     <!-- http://stackoverflow.com/questions/3584968/ant-how-to-compile-jar-that-includes-source-attachment -->
-    <javac sourcepath="" srcdir="src" destdir="src" debug="on" includeantruntime="false" >
+    <javac sourcepath="" srcdir="java" destdir="build/classes" debug="on" includeantruntime="false" >
       <include name="**/*.java"/>
       <compilerarg line="-encoding utf-8"/>
     </javac>
-    <jar basedir="src" destfile="bin/@JAR_NAME@"/>
+    <jar destfile="@OPENCV_JAR_FILE@">
+      <fileset dir="java"/>
+      <fileset dir="build/classes"/>
+      <manifest>
+        <attribute name="Specification-Title" value="OpenCV"/>
+        <attribute name="Specification-Version" value="@OPENCV_VERSION@"/>
+        <attribute name="Implementation-Title" value="OpenCV"/>
+        <attribute name="Implementation-Version" value="@OPENCV_VCSVERSION@"/>
+        <attribute name="Implementation-Date" value="${timestamp}"/>
+      </manifest>
+    </jar>
   </target>
 
   <target name="javadoc">
-    <tstamp>
-      <format property="doctimestamp" pattern="EEE MMM d yyyy HH:mm:ss z"/>
-    </tstamp>
     <javadoc
       packagenames="org.opencv.*"
-      sourcepath="src"
-      destdir="doc/javadoc"
+      sourcepath="java"
+      destdir="@OpenCV_BINARY_DIR@/doc/javadoc"
       Windowtitle="OpenCV @OPENCV_VERSION_PLAIN@ Java documentation"
       Doctitle="OpenCV Java documentation (@OPENCV_VERSION@)"
-      bottom="Generated on ${doctimestamp} / OpenCV @OPENCV_VCSVERSION@"
+      bottom="Generated on ${timestamp} / OpenCV @OPENCV_VCSVERSION@"
       />
   </target>
 

modules/java/jni/CMakeLists.txt

+project(${the_module})
+
+glob_more_specific_sources(H "${CMAKE_CURRENT_SOURCE_DIR}/../generator/src" handwritten_h_sources)
+glob_more_specific_sources(CPP "${CMAKE_CURRENT_SOURCE_DIR}/../generator/src" handwritten_cpp_sources)
+
+# grab C++ files from misc/java
+foreach(m ${OPENCV_MODULES_BUILD})
+  if (";${OPENCV_MODULE_${m}_WRAPPERS};" MATCHES ";java;" AND HAVE_${m})
+    set(module_java_dir "${OPENCV_MODULE_${m}_LOCATION}/misc/java")
+    include_directories("${module_java_dir}/src/cpp")
+    file(GLOB _result "${module_java_dir}/src/cpp/*.h" "${module_java_dir}/src/cpp/*.hpp" "${module_java_dir}/src/cpp/*.cpp")
+    list(APPEND handwritten_cpp_sources ${_result})
+  endif()
+endforeach()
+
+set(__type MODULE)
+if(BUILD_FAT_JAVA_LIB)
+  set(__type SHARED) # samples link to libopencv_java
+elseif(APPLE)
+  set(CMAKE_SHARED_MODULE_SUFFIX ".dylib")  # Java is not able to load .so files
+endif()
+ocv_add_library(${the_module} ${__type}
+    ${handwritten_h_sources} ${handwritten_cpp_sources} ${generated_cpp_sources}
+    ${copied_files}
+)
+add_dependencies(${the_module} gen_opencv_java_source)
+
+ocv_target_include_directories(${the_module} "${CMAKE_CURRENT_SOURCE_DIR}/../generator/src/cpp")
+ocv_target_include_directories(${the_module} "${OPENCV_JAVA_BINDINGS_DIR}/gen/cpp")
+ocv_target_include_modules(${the_module} ${OPENCV_MODULE_${the_module}_DEPS})
+if(NOT ANDROID)
+  ocv_target_include_directories(${the_module} SYSTEM ${JNI_INCLUDE_DIRS})
+endif()
+
+set(__deps ${OPENCV_MODULE_${the_module}_DEPS})
+list(REMOVE_ITEM __deps opencv_java_bindings_generator) # don't add dummy module to target_link_libraries list
+
+if(BUILD_FAT_JAVA_LIB)
+  ocv_list_unique(__deps)
+  set(__extradeps ${__deps})
+  ocv_list_filterout(__extradeps "^opencv_")
+  if(__extradeps)
+    list(REMOVE_ITEM __deps ${__extradeps})
+  endif()
+  if(APPLE)
+    foreach(_dep ${__deps})
+      ocv_target_link_libraries(${the_module} LINK_PRIVATE -Wl,-force_load "${_dep}")
+    endforeach()
+  elseif(((CMAKE_COMPILER_IS_GNUCXX 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)
+  else()
+    ocv_target_link_libraries(${the_module} LINK_PRIVATE ${__deps})
+  endif()
+  ocv_target_link_libraries(${the_module} LINK_PRIVATE ${__extradeps} ${OPENCV_LINKER_LIBS})
+else()
+  ocv_target_link_libraries(${the_module} LINK_PRIVATE ${__deps} ${OPENCV_LINKER_LIBS})
+endif()
+
+# Additional target properties
+set_target_properties(${the_module} PROPERTIES
+    OUTPUT_NAME "${the_module}${OPENCV_JAVA_LIB_NAME_SUFFIX}"
+    ARCHIVE_OUTPUT_DIRECTORY ${LIBRARY_OUTPUT_PATH}
+    LIBRARY_OUTPUT_DIRECTORY ${LIBRARY_OUTPUT_PATH}
+    RUNTIME_OUTPUT_DIRECTORY ${EXECUTABLE_OUTPUT_PATH}
+    DEFINE_SYMBOL CVAPI_EXPORTS
+    )
+
+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)
+
+  # force strip library after the build command
+  # because samples and tests will make a copy of the library before install
+  if(NOT CMAKE_BUILD_TYPE MATCHES "Debug")
+    add_custom_command(TARGET ${the_module} POST_BUILD COMMAND ${CMAKE_STRIP} --strip-unneeded "$<TARGET_FILE:${the_module}>")
+  endif()
+endif()
+
+if(ENABLE_SOLUTION_FOLDERS)
+  set_target_properties(${the_module} PROPERTIES FOLDER "bindings")
+endif()
+
+set(__install_export "")
+if(BUILD_FAT_JAVA_LIB)
+  set(__install_export EXPORT OpenCVModules)
+endif()
+
+ocv_install_target(${the_module} OPTIONAL ${__install_export}
+    RUNTIME DESTINATION ${OPENCV_JNI_BIN_INSTALL_PATH} COMPONENT java
+    LIBRARY DESTINATION ${OPENCV_JNI_INSTALL_PATH} COMPONENT java
+    ARCHIVE DESTINATION ${OPENCV_JNI_INSTALL_PATH} COMPONENT java
+)

modules/java/pure_test/CMakeLists.txt

-if(NOT ANT_EXECUTABLE
-  OR NOT BUILD_opencv_imgcodecs
-  OR NOT BUILD_opencv_calib3d)
-  return()
-endif()
-
-project(opencv_test_java)
-
-set(opencv_test_java_bin_dir "${CMAKE_CURRENT_BINARY_DIR}/.build")
-set(test_dir ${CMAKE_CURRENT_SOURCE_DIR})
-set(test_common_dir "${CMAKE_CURRENT_SOURCE_DIR}/../common_test")
-
-set(opencv_test_java_file_deps "")
-
-# make sure the build directory exists
-file(MAKE_DIRECTORY "${opencv_test_java_bin_dir}")
-
-# 1. gather and copy common test files (resources, utils, etc.)
-copy_common_tests(test_common_dir opencv_test_java_bin_dir opencv_test_java_file_deps)
-
-# 2. gather and copy tests from each module
-copy_modules_tests(OPENCV_JAVA_MODULES opencv_test_java_bin_dir opencv_test_java_file_deps)
-
-# 3. gather and copy specific files for pure java
-file(GLOB_RECURSE test_files RELATIVE "${test_dir}" "${test_dir}/src/*")
-file(GLOB_RECURSE test_lib_files RELATIVE "${test_dir}" "${test_dir}/lib/*.jar")
-foreach(f ${test_files} ${test_lib_files})
-  add_custom_command(OUTPUT "${opencv_test_java_bin_dir}/${f}"
-                     COMMAND ${CMAKE_COMMAND} -E copy_if_different "${test_dir}/${f}" "${opencv_test_java_bin_dir}/${f}"
-                     DEPENDS "${test_dir}/${f}"
-                     COMMENT "Copying ${f}"
-                    )
-  list(APPEND opencv_test_java_file_deps "${test_dir}/${f}" "${opencv_test_java_bin_dir}/${f}")
-endforeach()
-
-# Copy the OpenCV jar after it has been generated.
-add_custom_command(OUTPUT "${opencv_test_java_bin_dir}/bin/${JAR_NAME}"
-                   COMMAND ${CMAKE_COMMAND} -E copy_if_different "${JAR_FILE}" "${opencv_test_java_bin_dir}/bin/${JAR_NAME}"
-                   DEPENDS "${JAR_FILE}"
-                   COMMENT "Copying the OpenCV jar"
-                  )
-
-add_custom_command(OUTPUT "${opencv_test_java_bin_dir}/build.xml"
-                   COMMAND ${CMAKE_COMMAND} -E copy_if_different "${CMAKE_CURRENT_SOURCE_DIR}/build.xml" "${opencv_test_java_bin_dir}/build.xml"
-                   DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/build.xml"
-                   COMMENT "Copying build.xml"
-                  )
-
-add_custom_command(OUTPUT "${opencv_test_java_bin_dir}/build/jar/opencv-test.jar"
-                   COMMAND "${ANT_EXECUTABLE}" build
-                   WORKING_DIRECTORY "${opencv_test_java_bin_dir}"
-                   DEPENDS ${opencv_test_java_file_deps} "${opencv_test_java_bin_dir}/build.xml" "${CMAKE_CURRENT_SOURCE_DIR}/build.xml" "${JAR_FILE}" "${opencv_test_java_bin_dir}/bin/${JAR_NAME}"
-                   COMMENT "Build Java tests"
-                  )
-
-# Not add_custom_command because generator expressions aren't supported in
-# OUTPUT file names, and we need to generate different files for different
-# configurations.
-add_custom_target(${PROJECT_NAME}_properties
-                  COMMAND "${CMAKE_COMMAND}" -E echo "opencv.lib.path = $<TARGET_FILE_DIR:${the_module}>"
-                    > "${opencv_test_java_bin_dir}/ant-$<CONFIGURATION>.properties"
-                  VERBATIM
-                 )
-
-add_custom_target(${PROJECT_NAME} ALL
-                  DEPENDS ${the_module} ${PROJECT_NAME}_properties
-                  SOURCES "${opencv_test_java_bin_dir}/build/jar/opencv-test.jar"
-                 )
-
-if(ENABLE_SOLUTION_FOLDERS)
-  set_target_properties(${PROJECT_NAME} PROPERTIES FOLDER "tests accuracy")
-endif()

modules/java/android_test/CMakeLists.txt → modules/java/test/android_test/CMakeLists.txt

@@ -4,68 +4,74 @@ endif()
 
 project(opencv_test_java)
 
-set(opencv_test_java_bin_dir "${CMAKE_CURRENT_BINARY_DIR}/.build")
+set(OPENCV_JAVA_TEST_DIR "${OpenCV_BINARY_DIR}/android_test" CACHE INTERNAL "")
+file(REMOVE_RECURSE "${OPENCV_JAVA_TEST_DIR}")
+file(REMOVE "${OPENCV_DEPHELPER}/${the_module}_test_source_copy")
+
 set(test_dir "${CMAKE_CURRENT_SOURCE_DIR}")
-set(test_common_dir "${CMAKE_CURRENT_SOURCE_DIR}/../common_test")
 
-set(opencv_test_java_file_deps "")
+set(depends "")
 
 # 1. gather and copy common test files (resources, utils, etc.)
-copy_common_tests(test_common_dir opencv_test_java_bin_dir opencv_test_java_file_deps)
+copy_common_tests("${CMAKE_CURRENT_SOURCE_DIR}/../common_test" "${OPENCV_JAVA_TEST_DIR}" depends)
 
 # 2. gather and copy tests from each module
-copy_modules_tests(OPENCV_JAVA_MODULES opencv_test_java_bin_dir opencv_test_java_file_deps)
+ocv_copyfiles_append_dir(JAVA_TEST_SRC_COPY "${OPENCV_JAVA_BINDINGS_DIR}/gen/test" "${OPENCV_JAVA_TEST_DIR}/src")
+
+list(APPEND depends gen_opencv_java_source "${OPENCV_DEPHELPER}/gen_opencv_java_source")
+ocv_copyfiles_add_target(${the_module}_test_source_copy JAVA_TEST_SRC_COPY "Copy Java(Android test) source files" ${depends})
+set(depends ${the_module}_test_source_copy "${OPENCV_DEPHELPER}/${the_module}_test_source_copy")
 
 # 3. gather and copy specific files for Android
 file(GLOB_RECURSE test_files RELATIVE "${test_dir}" "${test_dir}/res/*" "${test_dir}/src/*")
 foreach(f ${test_files} ${ANDROID_MANIFEST_FILE} ".classpath" ".project")
   add_custom_command(
-      OUTPUT "${opencv_test_java_bin_dir}/${f}"
-      COMMAND ${CMAKE_COMMAND} -E copy_if_different "${test_dir}/${f}" "${opencv_test_java_bin_dir}/${f}"
+      OUTPUT "${OPENCV_JAVA_TEST_DIR}/${f}"
+      COMMAND ${CMAKE_COMMAND} -E copy_if_different "${test_dir}/${f}" "${OPENCV_JAVA_TEST_DIR}/${f}"
       MAIN_DEPENDENCY "${test_dir}/${f}"
       COMMENT "Copying ${f}")
-  list(APPEND opencv_test_java_file_deps "${test_dir}/${f}" "${opencv_test_java_bin_dir}/${f}")
+  list(APPEND depends "${test_dir}/${f}" "${OPENCV_JAVA_TEST_DIR}/${f}")
 endforeach()
 
 # fix Android project
 set(android_proj_target_files ${ANDROID_PROJECT_FILES})
-ocv_list_add_prefix(android_proj_target_files "${opencv_test_java_bin_dir}/")
-file(RELATIVE_PATH __dep "${opencv_test_java_bin_dir}" "${OpenCV_BINARY_DIR}")
+ocv_list_add_prefix(android_proj_target_files "${OPENCV_JAVA_TEST_DIR}/")
+file(RELATIVE_PATH __dep "${OPENCV_JAVA_TEST_DIR}" "${OpenCV_BINARY_DIR}/android_sdk")
 
 add_custom_command(
     OUTPUT ${android_proj_target_files}
     COMMAND ${CMAKE_COMMAND} -E remove ${android_proj_target_files}
-    COMMAND ${ANDROID_EXECUTABLE} --silent update test-project --path "${opencv_test_java_bin_dir}" --main "${OpenCV_BINARY_DIR}"
-    COMMAND ${ANDROID_EXECUTABLE} --silent update project --path "${opencv_test_java_bin_dir}" --library "${__dep}"
-    MAIN_DEPENDENCY "${opencv_test_java_bin_dir}/${ANDROID_MANIFEST_FILE}"
+    COMMAND ${ANDROID_EXECUTABLE} --silent update test-project --path "${OPENCV_JAVA_TEST_DIR}" --main "${OpenCV_BINARY_DIR}/android_sdk"
+    COMMAND ${ANDROID_EXECUTABLE} --silent update project --path "${OPENCV_JAVA_TEST_DIR}" --library "${__dep}"
+    MAIN_DEPENDENCY "${OPENCV_JAVA_TEST_DIR}/${ANDROID_MANIFEST_FILE}"
     DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/${ANDROID_MANIFEST_FILE}"
     COMMENT "Updating Android Java API test project")
 
-list(APPEND opencv_test_java_file_deps ${android_proj_target_files})
+list(APPEND depends ${android_proj_target_files})
 
 # build java part
 add_custom_command(
-    OUTPUT "${opencv_test_java_bin_dir}/bin/OpenCVTest-debug.apk"
-    COMMAND ${CMAKE_COMMAND} -E copy_if_different "$<TARGET_FILE:opencv_java>" "${opencv_test_java_bin_dir}/libs/${ANDROID_NDK_ABI_NAME}/$<TARGET_FILE_NAME:opencv_java>"
+    OUTPUT "${OPENCV_JAVA_TEST_DIR}/bin/OpenCVTest-debug.apk"
+    COMMAND ${CMAKE_COMMAND} -E copy_if_different "$<TARGET_FILE:opencv_java>" "${OPENCV_JAVA_TEST_DIR}/libs/${ANDROID_NDK_ABI_NAME}/$<TARGET_FILE_NAME:opencv_java>"
     COMMAND ${ANT_EXECUTABLE} -q -noinput -k debug -Djava.target=1.6 -Djava.source=1.6
-    COMMAND ${CMAKE_COMMAND} -E touch "${opencv_test_java_bin_dir}/bin/OpenCVTest-debug.apk" # needed because ant does not update the timestamp of updated apk
-    WORKING_DIRECTORY "${opencv_test_java_bin_dir}"
-    MAIN_DEPENDENCY "${opencv_test_java_bin_dir}/${ANDROID_MANIFEST_FILE}"
-    DEPENDS "${JAR_FILE}.dephelper" opencv_java
-    DEPENDS ${opencv_test_java_file_deps})
+    COMMAND ${CMAKE_COMMAND} -E touch "${OPENCV_JAVA_TEST_DIR}/bin/OpenCVTest-debug.apk" # needed because ant does not update the timestamp of updated apk
+    WORKING_DIRECTORY "${OPENCV_JAVA_TEST_DIR}"
+    MAIN_DEPENDENCY "${OPENCV_JAVA_TEST_DIR}/${ANDROID_MANIFEST_FILE}"
+    DEPENDS opencv_java_android opencv_java
+    DEPENDS ${depends})
 
-add_custom_target(${PROJECT_NAME} ALL SOURCES "${opencv_test_java_bin_dir}/bin/OpenCVTest-debug.apk" )
+add_custom_target(${PROJECT_NAME} ALL SOURCES "${OPENCV_JAVA_TEST_DIR}/bin/OpenCVTest-debug.apk" "${CMAKE_CURRENT_SOURCE_DIR}/${ANDROID_MANIFEST_FILE}")
 add_dependencies(${PROJECT_NAME} opencv_java ${__android_project_chain})
 set(__android_project_chain ${PROJECT_NAME} CACHE INTERNAL "auxiliary variable used for Android progects chaining" FORCE)
 
 # put the final .apk to the OpenCV's bin folder
-add_custom_command(TARGET ${PROJECT_NAME} POST_BUILD COMMAND ${CMAKE_COMMAND} -E copy_if_different "${opencv_test_java_bin_dir}/bin/OpenCVTest-debug.apk" "${OpenCV_BINARY_DIR}/bin/${PROJECT_NAME}.apk")
+add_custom_command(TARGET ${PROJECT_NAME} POST_BUILD COMMAND ${CMAKE_COMMAND} -E copy_if_different "${OPENCV_JAVA_TEST_DIR}/bin/OpenCVTest-debug.apk" "${OpenCV_BINARY_DIR}/bin/${PROJECT_NAME}.apk")
 
 add_dependencies(opencv_tests ${PROJECT_NAME})
 
 if(PYTHON_DEFAULT_AVAILABLE)
   set(CHECK_TEST_COVERAGE "${OPENCV_MODULE_opencv_java_LOCATION}/check-tests.py")
   add_custom_command(TARGET ${PROJECT_NAME} POST_BUILD
-      COMMAND ${PYTHON_DEFAULT_EXECUTABLE} ${CHECK_TEST_COVERAGE} "${CMAKE_CURRENT_SOURCE_DIR}/src" "${OpenCV_BINARY_DIR}/src" > "${CMAKE_CURRENT_BINARY_DIR}/tests_coverage.log"
+      COMMAND ${PYTHON_DEFAULT_EXECUTABLE} ${CHECK_TEST_COVERAGE} "${OPENCV_JAVA_TEST_DIR}/src" "${OPENCV_ANDROID_LIB_DIR}/src" > "${CMAKE_CURRENT_BINARY_DIR}/tests_coverage.log"
       )
 endif()

modules/java/test/pure_test/CMakeLists.txt

+if(NOT ANT_EXECUTABLE
+    OR NOT BUILD_opencv_imgcodecs
+    OR NOT BUILD_opencv_calib3d)
+  return()
+endif()
+
+project(opencv_test_java)
+
+set(OPENCV_JAR_FILE "${OPENCV_JAR_FILE}")
+get_filename_component(JAR_NAME "${OPENCV_JAR_FILE}" NAME)
+
+set(OPENCV_JAVA_TEST_DIR "${OpenCV_BINARY_DIR}/java_test" CACHE INTERNAL "")
+file(REMOVE_RECURSE "${OPENCV_JAVA_TEST_DIR}")
+file(MAKE_DIRECTORY "${OPENCV_JAVA_TEST_DIR}")
+file(REMOVE "${OPENCV_DEPHELPER}/${the_module}_test_source_copy")
+
+set(test_dir ${CMAKE_CURRENT_SOURCE_DIR})
+
+set(depends "")
+
+# 1. gather and copy common test files (resources, utils, etc.)
+copy_common_tests("${CMAKE_CURRENT_SOURCE_DIR}/../common_test" "${OPENCV_JAVA_TEST_DIR}" depends)
+
+# 2. gather and copy tests from each module
+ocv_copyfiles_append_dir(JAVA_TEST_SRC_COPY "${OPENCV_JAVA_BINDINGS_DIR}/gen/test" "${OPENCV_JAVA_TEST_DIR}/src")
+
+list(APPEND depends gen_opencv_java_source "${OPENCV_DEPHELPER}/gen_opencv_java_source")
+ocv_copyfiles_add_target(${the_module}_test_source_copy JAVA_TEST_SRC_COPY "Copy Java(Test) source files" ${depends})
+set(depends ${the_module}_test_source_copy "${OPENCV_DEPHELPER}/${the_module}_test_source_copy")
+
+# 3. gather and copy specific files for pure java
+file(GLOB_RECURSE test_files RELATIVE "${test_dir}" "${test_dir}/src/*")
+file(GLOB_RECURSE test_lib_files RELATIVE "${test_dir}" "${test_dir}/lib/*.jar")
+foreach(f ${test_files} ${test_lib_files})
+  add_custom_command(OUTPUT "${OPENCV_JAVA_TEST_DIR}/${f}"
+      COMMAND ${CMAKE_COMMAND} -E copy_if_different "${test_dir}/${f}" "${OPENCV_JAVA_TEST_DIR}/${f}"
+      DEPENDS "${test_dir}/${f}"
+      COMMENT "Copying ${f}"
+  )
+  list(APPEND depends "${test_dir}/${f}" "${OPENCV_JAVA_TEST_DIR}/${f}")
+endforeach()
+
+# Copy the OpenCV jar after it has been generated.
+add_custom_command(OUTPUT "${OPENCV_JAVA_TEST_DIR}/bin/${JAR_NAME}"
+    COMMAND ${CMAKE_COMMAND} -E copy_if_different "${OPENCV_JAR_FILE}" "${OPENCV_JAVA_TEST_DIR}/bin/${JAR_NAME}"
+    DEPENDS "${OPENCV_JAR_FILE}" "${OPENCV_DEPHELPER}/${the_module}_jar"
+    COMMENT "Copying the OpenCV jar"
+)
+
+add_custom_command(OUTPUT "${OPENCV_JAVA_TEST_DIR}/build.xml"
+    COMMAND ${CMAKE_COMMAND} -E copy_if_different "${CMAKE_CURRENT_SOURCE_DIR}/build.xml" "${OPENCV_JAVA_TEST_DIR}/build.xml"
+    DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/build.xml"
+    COMMENT "Copying build.xml"
+)
+
+add_custom_command(OUTPUT "${OPENCV_JAVA_TEST_DIR}/build/jar/opencv-test.jar"
+    COMMAND "${ANT_EXECUTABLE}" -noinput -k build
+    WORKING_DIRECTORY "${OPENCV_JAVA_TEST_DIR}"
+    DEPENDS ${depends} "${OPENCV_JAVA_TEST_DIR}/build.xml" "${CMAKE_CURRENT_SOURCE_DIR}/build.xml" "${OPENCV_JAR_FILE}" "${OPENCV_JAVA_TEST_DIR}/bin/${JAR_NAME}"
+    COMMENT "Build Java tests"
+)
+
+file(GENERATE OUTPUT "${OPENCV_JAVA_TEST_DIR}/ant-$<CONFIGURATION>.properties" CONTENT "opencv.lib.path=$<TARGET_FILE_DIR:${the_module}>")
+
+add_custom_target(${PROJECT_NAME} ALL
+    DEPENDS ${the_module} "${OPENCV_JAVA_TEST_DIR}/build/jar/opencv-test.jar"
+    SOURCES "${CMAKE_CURRENT_SOURCE_DIR}/build.xml"
+)
+
+if(ENABLE_SOLUTION_FOLDERS)
+  set_target_properties(${PROJECT_NAME} PROPERTIES FOLDER "tests accuracy")
+endif()
+
+add_dependencies(opencv_tests ${PROJECT_NAME})

modules/java/pure_test/build.xml → modules/java/test/pure_test/build.xml

-<project>
+<project name="OpenCV-Test">
   <property environment="env"/>
   <property file="ant-${opencv.build.type}.properties"/>
   <property name="test.dir" value="testResults"/>
@@ -27,7 +27,7 @@
     </javac>
   </target>
 
-  <target name="jar">
+  <target name="jar" depends="compile">
     <mkdir dir="build/jar"/>
     <jar destfile="build/jar/opencv-test.jar" basedir="build/classes">
       <manifest>
@@ -36,7 +36,7 @@
     </jar>
   </target>
 
-  <target name="test">
+  <target name="test" depends="jar">
     <mkdir dir="${test.dir}"/>
     <junit printsummary="true" haltonfailure="false" haltonerror="false" showoutput="true" logfailedtests="true" maxmemory="256m">
       <sysproperty key="java.library.path" path="${opencv.lib.path}"/>
@@ -62,14 +62,9 @@
     </junitreport>
   </target>
 
-  <target name="build">
-    <antcall target="compile"/>
-    <antcall target="jar"/>
+  <target name="build" depends="jar">
   </target>
 
-  <target name="buildAndTest">
-    <antcall target="compile"/>
-    <antcall target="jar"/>
-    <antcall target="test"/>
+  <target name="buildAndTest" depends="test">
   </target>
 </project>

modules/ts/misc/run_suite.py

@@ -127,7 +127,7 @@ class TestSuite(object):
         exe = os.path.abspath(path)
         if path == "java":
             cmd = [self.cache.ant_executable, "-Dopencv.build.type=%s" % self.cache.build_type, "buildAndTest"]
-            ret = execute(cmd, cwd = self.cache.java_test_binary_dir + "/.build")
+            ret = execute(cmd, cwd = self.cache.java_test_dir)
             return None, ret
         elif path in ['python2', 'python3']:
             executable = os.getenv('OPENCV_PYTHON_BINARY', None)

modules/ts/misc/run_utils.py

@@ -168,7 +168,7 @@ parse_patterns = (
     {'name': "android_abi",              'default': None,       'pattern': re.compile(r"^ANDROID_ABI:STRING=(.*)$")},
     {'name': "android_executable",       'default': None,       'pattern': re.compile(r"^ANDROID_EXECUTABLE:FILEPATH=(.*android.*)$")},
     {'name': "ant_executable",           'default': None,       'pattern': re.compile(r"^ANT_EXECUTABLE:FILEPATH=(.*ant.*)$")},
-    {'name': "java_test_binary_dir",     'default': None,       'pattern': re.compile(r"^opencv_test_java_BINARY_DIR:STATIC=(.*)$")},
+    {'name': "java_test_dir",            'default': None,       'pattern': re.compile(r"^OPENCV_JAVA_TEST_DIR:\w+=(.*)$")},
     {'name': "is_x64",                   'default': "OFF",      'pattern': re.compile(r"^CUDA_64_BIT_DEVICE_CODE:BOOL=(ON)$")},#ugly(
     {'name': "cmake_generator",          'default': None,       'pattern': re.compile(r"^CMAKE_GENERATOR:INTERNAL=(.+)$")},
     {'name': "cxx_compiler",             'default': None,       'pattern': re.compile(r"^CMAKE_CXX_COMPILER:\w*PATH=(.+)$")},
@@ -269,7 +269,7 @@ class CMakeCache:
         return self.cuda_version and self.with_cuda == "ON" and self.cuda_library and not self.cuda_library.endswith("-NOTFOUND")
 
     def withJava(self):
-        return self.ant_executable and self.java_test_binary_dir
+        return self.ant_executable and os.path.exists(self.java_test_dir)
 
     def withPython2(self):
         return self.python2 == 'ON'

modules/videoio/misc/java/test/VideoCaptureTest.java

-package org.opencv.test.highgui;
+package org.opencv.test.videoio;
 
 import java.util.List;
 

platforms/android/build_sdk.py

@@ -60,6 +60,39 @@ def determine_opencv_version(version_hpp_path):
         version_status = re.search(r'^#define\W+CV_VERSION_STATUS\W+"([^"]*)"$', data, re.MULTILINE).group(1)
         return "%(major)s.%(minor)s.%(revision)s%(version_status)s" % locals()
 
+# shutil.move fails if dst exists
+def move_smart(src, dst):
+    def move_recurse(subdir):
+        s = os.path.join(src, subdir)
+        d = os.path.join(dst, subdir)
+        if os.path.exists(d):
+            if os.path.isdir(d):
+                for item in os.listdir(s):
+                    move_recurse(os.path.join(subdir, item))
+            elif os.path.isfile(s):
+                shutil.move(s, d)
+        else:
+            shutil.move(s, d)
+    move_recurse('')
+
+# shutil.copytree fails if dst exists
+def copytree_smart(src, dst):
+    def copy_recurse(subdir):
+        s = os.path.join(src, subdir)
+        d = os.path.join(dst, subdir)
+        if os.path.exists(d):
+            if os.path.isdir(d):
+                for item in os.listdir(s):
+                    copy_recurse(os.path.join(subdir, item))
+            elif os.path.isfile(s):
+                shutil.copy2(s, d)
+        else:
+            if os.path.isdir(s):
+                shutil.copytree(s, d)
+            elif os.path.isfile(s):
+                shutil.copy2(s, d)
+    copy_recurse('')
+
 #===================================================================================================
 
 class ABI:
@@ -88,13 +121,14 @@ ABIs = [
 #===================================================================================================
 
 class Builder:
-    def __init__(self, workdir, opencvdir):
+    def __init__(self, workdir, opencvdir, config):
         self.workdir = check_dir(workdir, create=True)
         self.opencvdir = check_dir(opencvdir)
+        self.config = config
         self.extra_modules_path = None
         self.libdest = check_dir(os.path.join(self.workdir, "o4a"), create=True, clean=True)
-        self.docdest = check_dir(os.path.join(self.workdir, "javadoc"), create=True, clean=True)
-        self.resultdest = check_dir(os.path.join(self.workdir, "OpenCV-android-sdk"), create=True, clean=True)
+        self.resultdest = check_dir(os.path.join(self.workdir, 'OpenCV-android-sdk'), create=True, clean=True)
+        self.docdest = check_dir(os.path.join(self.workdir, 'OpenCV-android-sdk', 'sdk', 'java', 'javadoc'), create=True, clean=True)
         self.extra_packs = []
         self.opencv_version = determine_opencv_version(os.path.join(self.opencvdir, "modules", "core", "include", "opencv2", "core", "version.hpp"))
         self.engine_version = determine_engine_version(os.path.join(self.opencvdir, "platforms", "android", "service", "engine", "AndroidManifest.xml"))
@@ -168,6 +202,7 @@ class Builder:
         ]
         execute(cmd)
         apkdest = self.get_engine_apk_dest(engdest)
+        assert os.path.exists(apkdest), apkdest
         # Add extra data
         apkxmldest = check_dir(os.path.join(apkdest, "res", "xml"), create=True)
         apklibdest = check_dir(os.path.join(apkdest, "libs", abi.name), create=True)
@@ -194,7 +229,7 @@ class Builder:
         # TODO: Sign apk
 
     def build_javadoc(self):
-        classpaths = [os.path.join(self.libdest, "bin", "classes")]
+        classpaths = []
         for dir, _, files in os.walk(os.environ["ANDROID_SDK"]):
             for f in files:
                 if f == "android.jar" or f == "annotations.jar":
@@ -205,37 +240,42 @@ class Builder:
             "-nodeprecated",
             "-footer", '<a href="http://docs.opencv.org">OpenCV %s Documentation</a>' % self.opencv_version,
             "-public",
-            "-sourcepath", os.path.join(self.libdest, "src"),
+            '-sourcepath', os.path.join(self.resultdest, 'sdk', 'java', 'src'),
             "-d", self.docdest,
-            "-classpath", ":".join(classpaths)
+            "-classpath", ":".join(classpaths),
+            '-subpackages', 'org.opencv',
         ]
-        for _, dirs, _ in os.walk(os.path.join(self.libdest, "src", "org", "opencv")):
-            cmd.extend(["org.opencv." + d for d in dirs])
         execute(cmd)
 
     def gather_results(self, engines):
         # Copy all files
         root = os.path.join(self.libdest, "install")
         for item in os.listdir(root):
-            name = item
-            item = os.path.join(root, item)
-            if os.path.isdir(item):
+            src = os.path.join(root, item)
+            dst = os.path.join(self.resultdest, item)
+            if os.path.isdir(src):
                 log.info("Copy dir: %s", item)
-                shutil.copytree(item, os.path.join(self.resultdest, name))
-            elif os.path.isfile(item):
+                if self.config.force_copy:
+                    copytree_smart(src, dst)
+                else:
+                    move_smart(src, dst)
+            elif os.path.isfile(src):
                 log.info("Copy file: %s", item)
-                shutil.copy2(item, os.path.join(self.resultdest, name))
+                if self.config.force_copy:
+                    shutil.copy2(src, dst)
+                else:
+                    shutil.move(src, dst)
 
         # Copy engines for all platforms
         for abi, engdest in engines:
             log.info("Copy engine: %s (%s)", abi, engdest)
             f = os.path.join(self.get_engine_apk_dest(engdest), "bin", "opencv_engine-debug.apk")
             resname = "OpenCV_%s_Manager_%s_%s.apk" % (self.opencv_version, self.engine_version, abi)
-            shutil.copy2(f, os.path.join(self.resultdest, "apk", resname))
-
-        # Copy javadoc
-        log.info("Copy docs: %s", self.docdest)
-        shutil.copytree(self.docdest, os.path.join(self.resultdest, "sdk", "java", "javadoc"))
+            dst = os.path.join(self.resultdest, "apk", resname)
+            if self.config.force_copy:
+                shutil.copy2(f, dst)
+            else:
+                shutil.move(f, dst)
 
         # Clean samples
         path = os.path.join(self.resultdest, "samples")
@@ -259,6 +299,7 @@ if __name__ == "__main__":
     parser.add_argument('--build_doc', action="store_true", help="Build javadoc")
     parser.add_argument('--no_ccache', action="store_true", help="Do not use ccache during library build")
     parser.add_argument('--extra_pack', action='append', help="provide extra OpenCV libraries for Manager apk in form <version>:<path-to-native-libs>, for example '2.4.11:unpacked/sdk/native/libs'")
+    parser.add_argument('--force_copy', action="store_true", help="Do not use file move during library build (useful for debug)")
     args = parser.parse_args()
 
     log.basicConfig(format='%(message)s', level=log.DEBUG)
@@ -272,7 +313,7 @@ if __name__ == "__main__":
     log.info("Android NDK path: %s", os.environ["ANDROID_NDK"])
     log.info("Android SDK path: %s", os.environ["ANDROID_SDK"])
 
-    builder = Builder(args.work_dir, args.opencv_dir)
+    builder = Builder(args.work_dir, args.opencv_dir, args)
 
     if args.extra_modules_path is not None:
         builder.extra_modules_path = os.path.abspath(args.extra_modules_path)
@@ -312,11 +353,11 @@ if __name__ == "__main__":
         builder.build_engine(abi, engdest)
         engines.append((abi.name, engdest))
 
+    builder.gather_results(engines)
+
     if args.build_doc:
         builder.build_javadoc()
 
-    builder.gather_results(engines)
-
     log.info("=====")
     log.info("===== Build finished")
     log.info("=====")

platforms/android/service/engine/src/org/opencv/engine/OpenCVEngineService.java

@@ -88,7 +88,7 @@ public class OpenCVEngineService extends Service {
 
     public void onCreate() {
         Log.d(TAG, "Service starting");
-        for (Field field : R.xml.class.getDeclaredFields()) {
+        for (Field field : R.xml.class.getDeclaredFields()) {  // Build error here means that all config.xml files are missing (configuration problem)
             Log.d(TAG, "Found config: " + field.getName());
             final LibVariant lib = new LibVariant();
             try {

samples/android/15-puzzle/CMakeLists.txt

 set(sample example-15-puzzle)
 
-add_android_project(${sample} "${CMAKE_CURRENT_SOURCE_DIR}" LIBRARY_DEPS ${OpenCV_BINARY_DIR} SDK_TARGET 11 ${ANDROID_SDK_TARGET})
+add_android_project(${sample} "${CMAKE_CURRENT_SOURCE_DIR}" LIBRARY_DEPS "${OPENCV_ANDROID_LIB_DIR}" SDK_TARGET 11 "${ANDROID_SDK_TARGET}")
 if(TARGET ${sample})
   add_dependencies(opencv_android_examples ${sample})
 endif()

samples/android/camera-calibration/CMakeLists.txt

 set(sample example-camera-calibration)
 
-add_android_project(${sample} "${CMAKE_CURRENT_SOURCE_DIR}" LIBRARY_DEPS ${OpenCV_BINARY_DIR} SDK_TARGET 11 ${ANDROID_SDK_TARGET})
+add_android_project(${sample} "${CMAKE_CURRENT_SOURCE_DIR}" LIBRARY_DEPS "${OPENCV_ANDROID_LIB_DIR}" SDK_TARGET 11 "${ANDROID_SDK_TARGET}")
 if(TARGET ${sample})
   add_dependencies(opencv_android_examples ${sample})
 endif()

samples/android/color-blob-detection/CMakeLists.txt

 set(sample example-color-blob-detection)
 
-add_android_project(${sample} "${CMAKE_CURRENT_SOURCE_DIR}" LIBRARY_DEPS ${OpenCV_BINARY_DIR} SDK_TARGET 11 ${ANDROID_SDK_TARGET})
+add_android_project(${sample} "${CMAKE_CURRENT_SOURCE_DIR}" LIBRARY_DEPS "${OPENCV_ANDROID_LIB_DIR}" SDK_TARGET 11 "${ANDROID_SDK_TARGET}")
 if(TARGET ${sample})
   add_dependencies(opencv_android_examples ${sample})
 endif()

samples/android/face-detection/CMakeLists.txt

@@ -3,10 +3,10 @@ set(sample example-face-detection)
 if(BUILD_FAT_JAVA_LIB)
   set(native_deps opencv_java)
 else()
-  set(native_deps opencv_contrib)
+  set(native_deps opencv_objdetect)
 endif()
 
-add_android_project(${sample} "${CMAKE_CURRENT_SOURCE_DIR}" LIBRARY_DEPS ${OpenCV_BINARY_DIR} SDK_TARGET 11 ${ANDROID_SDK_TARGET} NATIVE_DEPS ${native_deps})
+add_android_project(${sample} "${CMAKE_CURRENT_SOURCE_DIR}" LIBRARY_DEPS "${OPENCV_ANDROID_LIB_DIR}" SDK_TARGET 11 "${ANDROID_SDK_TARGET}" NATIVE_DEPS ${native_deps})
 if(TARGET ${sample})
   add_dependencies(opencv_android_examples ${sample})
 endif()

samples/android/image-manipulations/CMakeLists.txt

 set(sample example-image-manipulations)
 
-add_android_project(${sample} "${CMAKE_CURRENT_SOURCE_DIR}" LIBRARY_DEPS ${OpenCV_BINARY_DIR} SDK_TARGET 11 ${ANDROID_SDK_TARGET})
+add_android_project(${sample} "${CMAKE_CURRENT_SOURCE_DIR}" LIBRARY_DEPS "${OPENCV_ANDROID_LIB_DIR}" SDK_TARGET 11 "${ANDROID_SDK_TARGET}")
 if(TARGET ${sample})
   add_dependencies(opencv_android_examples ${sample})
 endif()

samples/android/mobilenet-objdetect/CMakeLists.txt

 set(sample example-mobilenet-objdetect)
 
-add_android_project(${sample} "${CMAKE_CURRENT_SOURCE_DIR}" LIBRARY_DEPS ${OpenCV_BINARY_DIR} SDK_TARGET 11 ${ANDROID_SDK_TARGET})
+add_android_project(${sample} "${CMAKE_CURRENT_SOURCE_DIR}" LIBRARY_DEPS "${OPENCV_ANDROID_LIB_DIR}" SDK_TARGET 11 "${ANDROID_SDK_TARGET}")
 if(TARGET ${sample})
   add_dependencies(opencv_android_examples ${sample})
 endif()

samples/android/tutorial-1-camerapreview/CMakeLists.txt

 set(sample example-tutorial-1-camerapreview)
 
-add_android_project(${sample} "${CMAKE_CURRENT_SOURCE_DIR}" LIBRARY_DEPS ${OpenCV_BINARY_DIR} SDK_TARGET 11 ${ANDROID_SDK_TARGET})
+add_android_project(${sample} "${CMAKE_CURRENT_SOURCE_DIR}" LIBRARY_DEPS "${OPENCV_ANDROID_LIB_DIR}" SDK_TARGET 11 "${ANDROID_SDK_TARGET}")
 if(TARGET ${sample})
   add_dependencies(opencv_android_examples ${sample})
 endif()

samples/android/tutorial-2-mixedprocessing/CMakeLists.txt

@@ -6,7 +6,7 @@ else()
   set(native_deps opencv_features2d)
 endif()
 
-add_android_project(${sample} "${CMAKE_CURRENT_SOURCE_DIR}" LIBRARY_DEPS ${OpenCV_BINARY_DIR} SDK_TARGET 11 ${ANDROID_SDK_TARGET} NATIVE_DEPS ${native_deps})
+add_android_project(${sample} "${CMAKE_CURRENT_SOURCE_DIR}" LIBRARY_DEPS "${OPENCV_ANDROID_LIB_DIR}" SDK_TARGET 11 "${ANDROID_SDK_TARGET}" NATIVE_DEPS ${native_deps})
 if(TARGET ${sample})
   add_dependencies(opencv_android_examples ${sample})
 endif()

samples/android/tutorial-3-cameracontrol/CMakeLists.txt

 set(sample example-tutorial-3-cameracontrol)
 
-add_android_project(${sample} "${CMAKE_CURRENT_SOURCE_DIR}" LIBRARY_DEPS ${OpenCV_BINARY_DIR} SDK_TARGET 11 ${ANDROID_SDK_TARGET})
+add_android_project(${sample} "${CMAKE_CURRENT_SOURCE_DIR}" LIBRARY_DEPS "${OPENCV_ANDROID_LIB_DIR}" SDK_TARGET 11 "${ANDROID_SDK_TARGET}")
 if(TARGET ${sample})
   add_dependencies(opencv_android_examples ${sample})
 endif()

samples/android/tutorial-4-opencl/CMakeLists.txt

@@ -17,8 +17,8 @@ endif()
 include_directories(${ANDROID_OPENCL_SDK}/include)
 link_directories(${ANDROID_OPENCL_SDK}/lib/${ANDROID_NDK_ABI_NAME})
 add_android_project(${sample} "${CMAKE_CURRENT_SOURCE_DIR}"
-    LIBRARY_DEPS ${OpenCV_BINARY_DIR}
-    SDK_TARGET 21 ${ANDROID_SDK_TARGET}
+    LIBRARY_DEPS "${OPENCV_ANDROID_LIB_DIR}"
+    SDK_TARGET 21 "${ANDROID_SDK_TARGET}"
     NATIVE_DEPS ${native_deps} -lGLESv2 -lEGL -lOpenCL
     COPY_LIBS YES
 )