Adjust Android Manager version from 2.2 to 2.3

The documentation is available online at http://opencv.org/documentation.html

3rdparty/libjasper/CMakeLists.txt

@@ -24,6 +24,7 @@ if(WIN32 AND NOT MINGW)
 endif(WIN32 AND NOT MINGW)
 
 ocv_warnings_disable(CMAKE_C_FLAGS -Wno-implicit-function-declaration -Wno-uninitialized -Wmissing-prototypes -Wmissing-declarations -Wunused -Wshadow -Wsign-compare)
+ocv_warnings_disable(CMAKE_C_FLAGS -Wunused-parameter) # clang
 ocv_warnings_disable(CMAKE_C_FLAGS /wd4013 /wd4018 /wd4101 /wd4244 /wd4267 /wd4715) # vs2005
 
 if(UNIX)

3rdparty/libjpeg/CMakeLists.txt

@@ -26,6 +26,7 @@ if(CMAKE_COMPILER_IS_GNUCXX)
 endif()
 
 ocv_warnings_disable(CMAKE_C_FLAGS -Wcast-align -Wshadow -Wunused)
+ocv_warnings_disable(CMAKE_C_FLAGS -Wunused-parameter) # clang
 
 set_target_properties(${JPEG_LIBRARY}
   PROPERTIES OUTPUT_NAME ${JPEG_LIBRARY}

3rdparty/libtiff/CMakeLists.txt

@@ -89,6 +89,7 @@ endif(WIN32)
 
 ocv_warnings_disable(CMAKE_C_FLAGS -Wno-unused-but-set-variable -Wmissing-prototypes -Wmissing-declarations -Wundef -Wunused -Wsign-compare
                                    -Wcast-align -Wshadow -Wno-maybe-uninitialized -Wno-pointer-to-int-cast -Wno-int-to-pointer-cast)
+ocv_warnings_disable(CMAKE_C_FLAGS -Wunused-parameter) # clang
 ocv_warnings_disable(CMAKE_CXX_FLAGS -Wmissing-declarations -Wunused-parameter)
 ocv_warnings_disable(CMAKE_CXX_FLAGS /wd4018 /wd4100 /wd4127 /wd4311 /wd4701 /wd4706) # vs2005
 ocv_warnings_disable(CMAKE_CXX_FLAGS /wd4244) # vs2008

3rdparty/tbb/CMakeLists.txt

@@ -5,40 +5,46 @@ endif()
 
 project(tbb)
 
-# 4.1 - works fine
-set(tbb_ver "tbb41_20120718oss")
-set(tbb_url "http://threadingbuildingblocks.org/uploads/77/188/4.1/tbb41_20120718oss_src.tgz")
-set(tbb_md5 "31b9ec300f3d09da2504d5d882788dd4")
+# 4.1 update 1 - works fine
+set(tbb_ver "tbb41_20121003oss")
+set(tbb_url "http://threadingbuildingblocks.org/sites/default/files/software_releases/source/tbb41_20121003oss_src.tgz")
+set(tbb_md5 "2a684fefb855d2d0318d1ef09afa75ff")
 set(tbb_version_file "version_string.ver")
 
+# 4.1 - works fine
+#set(tbb_ver "tbb41_20120718oss")
+#set(tbb_url "http://threadingbuildingblocks.org/sites/default/files/software_releases/source/tbb41_20120718oss_src.tgz")
+#set(tbb_md5 "31b9ec300f3d09da2504d5d882788dd4")
+#set(tbb_version_file "version_string.ver")
+
 # 4.0 update 5 - works fine
 #set(tbb_ver "tbb40_20120613oss")
-#set(tbb_url "http://threadingbuildingblocks.org/uploads/77/187/4.0%20update%205/tbb40_20120613oss_src.tgz")
+#set(tbb_url "http://threadingbuildingblocks.org/sites/default/files/software_releases/source/tbb40_20120613oss_src.tgz")
 #set(tbb_md5 "da01ed74944ec5950cfae3476901a172")
 #set(tbb_version_file "version_string.ver")
 
 # 4.0 update 4 - works fine
 #set(tbb_ver "tbb40_20120408oss")
-#set(tbb_url "http://threadingbuildingblocks.org/uploads/77/185/4.0%20update%204/tbb40_20120408oss_src.tgz")
+#set(tbb_url "http://threadingbuildingblocks.org/sites/default/files/software_releases/source/tbb40_20120408oss_src.tgz")
 #set(tbb_md5 "734b356da7fe0ed308741f3e6018251e")
 #set(tbb_version_file "version_string.ver")
 
 # 4.0 update 3 - build broken
 #set(tbb_ver "tbb40_20120201oss")
-#set(tbb_url "http://threadingbuildingblocks.org/uploads/77/182/4.0%20update%203/tbb40_20120201oss_src.tgz")
+#set(tbb_url "http://threadingbuildingblocks.org/sites/default/files/software_releases/source/tbb40_20120201oss_src.tgz")
 #set(tbb_md5 "4669e7d4adee018de7a7b8b972987218")
 #set(tbb_version_file "version_string.tmp")
 
 # 4.0 update 2 - works fine
 #set(tbb_ver "tbb40_20111130oss")
-#set(tbb_url "http://threadingbuildingblocks.org/uploads/77/180/4.0%20update%202/tbb40_20111130oss_src.tgz")
+#set(tbb_url "http://threadingbuildingblocks.org/sites/default/files/software_releases/source/tbb40_20111130oss_src.tgz")
 #set(tbb_md5 "1e6926b21e865e79772119cd44fc3ad8")
 #set(tbb_version_file "version_string.tmp")
 #set(tbb_need_GENERIC_DWORD_LOAD_STORE TRUE)
 
 # 4.0 update 1 - works fine
 #set(tbb_ver "tbb40_20111003oss")
-#set(tbb_url "http://threadingbuildingblocks.org/uploads/77/177/4.0%20update%201/tbb40_20111003oss_src.tgz")
+#set(tbb_url "http://threadingbuildingblocks.org/sites/default/files/software_releases/source/tbb40_20111003oss_src.tgz")
 #set(tbb_md5 "7b5d94eb35a563b29ef402e0fd8f15c9")
 #set(tbb_version_file "version_string.tmp")
 #set(tbb_need_GENERIC_DWORD_LOAD_STORE TRUE)
@@ -123,6 +129,11 @@ add_definitions(-D__TBB_DYNAMIC_LOAD_ENABLED=0         #required
                 -DDO_ITT_NOTIFY=0                      #it seems that we don't need these notifications
                )
 
+if(ANDROID_COMPILER_IS_CLANG)
+  add_definitions(-D__TBB_GCC_BUILTIN_ATOMICS_PRESENT=1)
+  ocv_warnings_disable(CMAKE_CXX_FLAGS -Wmissing-prototypes)
+endif()
+
 if(tbb_need_GENERIC_DWORD_LOAD_STORE)
   #needed by TBB 4.0 update 1,2; fixed in TBB 4.0 update 3 but it has 2 new problems
   add_definitions(-D__TBB_USE_GENERIC_DWORD_LOAD_STORE=1)

CMakeLists.txt

@@ -157,7 +157,7 @@ OCV_OPTION(BUILD_TESTS              "Build accuracy & regression tests"
 OCV_OPTION(BUILD_WITH_DEBUG_INFO    "Include debug info into debug libs (not MSCV only)" ON )
 OCV_OPTION(BUILD_WITH_STATIC_CRT    "Enables use of staticaly linked CRT for staticaly linked OpenCV" ON IF MSVC )
 OCV_OPTION(BUILD_FAT_JAVA_LIB       "Create fat java wrapper containing the whole OpenCV library" ON IF ANDROID AND NOT BUILD_SHARED_LIBS AND CMAKE_COMPILER_IS_GNUCXX )
-OCV_OPTION(BUILD_ANDROID_SERVICE    "Build OpenCV Manager for Google Play" OFF IF ANDROID AND ANDROID_USE_STLPORT AND ANDROID_SOURCE_TREE )
+OCV_OPTION(BUILD_ANDROID_SERVICE    "Build OpenCV Manager for Google Play" OFF IF ANDROID AND ANDROID_SOURCE_TREE )
 OCV_OPTION(BUILD_ANDROID_PACKAGE    "Build platform-specific package for Google Play" OFF IF ANDROID )
 
 # 3rd party libs
@@ -467,6 +467,10 @@ if(BUILD_ANDROID_PACKAGE)
   add_subdirectory(android/package)
 endif()
 
+if (ANDROID)
+  add_subdirectory(android/libinfo)
+endif()
+
 # ----------------------------------------------------------------------------
 # Finalization: generate configuration-based files
 # ----------------------------------------------------------------------------
@@ -489,7 +493,7 @@ include(cmake/OpenCVGenConfig.cmake)
 # Summary:
 # ----------------------------------------------------------------------------
 status("")
-status("General configuration for OpenCV ${OPENCV_VERSION}-rc =====================================")
+status("General configuration for OpenCV ${OPENCV_VERSION} =====================================")
 if(OPENCV_VCSVERSION)
   status("  Version control:" ${OPENCV_VCSVERSION})
 endif()

android/README.android

@@ -1 +1 @@
-See http://code.opencv.org/projects/opencv/wiki/OpenCV4Android
+See http://opencv.org/android

android/android.toolchain.cmake

@@ -1,7 +1,37 @@
+# Copyright (c) 2010-2011, Ethan Rublee
+# Copyright (c) 2011-2012, Andrey Kamaev
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# 1.  Redistributions of source code must retain the above copyright notice,
+#     this list of conditions and the following disclaimer.
+#
+# 2.  Redistributions in binary form must reproduce the above copyright notice,
+#     this list of conditions and the following disclaimer in the documentation
+#     and/or other materials provided with the distribution.
+#
+# 3.  The name of the copyright holders may be used to endorse or promote
+#     products derived from this software without specific prior written
+#     permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+
 # ------------------------------------------------------------------------------
 #  Android CMake toolchain file, for use with the Android NDK r5-r8
 #  Requires cmake 2.6.3 or newer (2.8.5 or newer is recommended).
-#  See home page: http://code.google.com/p/android-cmake/
+#  See home page: https://github.com/taka-no-me/android-cmake
 #
 #  The file is mantained by the OpenCV project. The latest version can be get at
 #  http://code.opencv.org/projects/opencv/repository/revisions/master/changes/android/android.toolchain.cmake
@@ -64,6 +94,20 @@
 #    ANDROID_NATIVE_API_LEVEL=android-8 - level of Android API compile for.
 #      Option is read-only when standalone toolchain is used.
 #
+#    ANDROID_TOOLCHAIN_NAME=arm-linux-androideabi-4.6 - the name of compiler
+#      toolchain to be used. The list of possible values depends on the NDK
+#      version. For NDK r8c the possible values are:
+#
+#        * arm-linux-androideabi-4.4.3
+#        * arm-linux-androideabi-4.6
+#        * arm-linux-androideabi-clang3.1
+#        * mipsel-linux-android-4.4.3
+#        * mipsel-linux-android-4.6
+#        * mipsel-linux-android-clang3.1
+#        * x86-4.4.3
+#        * x86-4.6
+#        * x86-clang3.1
+#
 #    ANDROID_FORCE_ARM_BUILD=OFF - set ON to generate 32-bit ARM instructions
 #      instead of Thumb. Is not available for "x86" (inapplicable) and
 #      "armeabi-v6 with VFP" (is forced to be ON) ABIs.
@@ -147,13 +191,9 @@
 #    under the ${LIBRARY_OUTPUT_PATH_ROOT}/libs/${ANDROID_NDK_ABI_NAME}
 #    (depending on the target ABI). This is convenient for Android packaging.
 #
-#  Authors:
-#    Ethan Rublee ethan.ruble@gmail.com
-#    Andrey Kamaev andrey.kamaev@itseez.com
-#
 #  Change Log:
 #   - initial version December 2010
-#   - modified April 2011
+#   - April 2011
 #     [+] added possibility to build with NDK (without standalone toolchain)
 #     [+] support cross-compilation on Windows (native, no cygwin support)
 #     [+] added compiler option to force "char" type to be signed
@@ -164,13 +204,13 @@
 #     [+] EXECUTABLE_OUTPUT_PATH is set by toolchain (required on Windows)
 #     [~] Fixed bug with ANDROID_API_LEVEL variable
 #     [~] turn off SWIG search if it is not found first time
-#   - modified May 2011
+#   - May 2011
 #     [~] ANDROID_LEVEL is renamed to ANDROID_API_LEVEL
 #     [+] ANDROID_API_LEVEL is detected by toolchain if not specified
 #     [~] added guard to prevent changing of output directories on the first
 #         cmake pass
 #     [~] toolchain exits with error if ARM_TARGET is not recognized
-#   - modified June 2011
+#   - June 2011
 #     [~] default NDK path is updated for version r5c
 #     [+] variable CMAKE_SYSTEM_PROCESSOR is set based on ARM_TARGET
 #     [~] toolchain install directory is added to linker paths
@@ -178,13 +218,13 @@
 #     [+] added macro find_host_package, find_host_program to search
 #         packages/programs on the host system
 #     [~] fixed path to STL library
-#   - modified July 2011
+#   - July 2011
 #     [~] fixed options caching
 #     [~] search for all supported NDK versions
 #     [~] allowed spaces in NDK path
-#   - modified September 2011
+#   - September 2011
 #     [~] updated for NDK r6b
-#   - modified November 2011
+#   - November 2011
 #     [*] rewritten for NDK r7
 #     [+] x86 toolchain support (experimental)
 #     [+] added "armeabi-v6 with VFP" ABI for ARMv6 processors.
@@ -197,37 +237,37 @@
 #     [~] ARM_TARGET is renamed to ANDROID_ABI
 #     [~] ARMEABI_NDK_NAME is renamed to ANDROID_NDK_ABI_NAME
 #     [~] ANDROID_API_LEVEL is renamed to ANDROID_NATIVE_API_LEVEL
-#   - modified January 2012
+#   - January 2012
 #     [+] added stlport_static support (experimental)
 #     [+] added special check for cygwin
 #     [+] filtered out hidden files (starting with .) while globbing inside NDK
 #     [+] automatically applied GLESv2 linkage fix for NDK revisions 5-6
 #     [+] added ANDROID_GET_ABI_RAWNAME to get NDK ABI names by CMake flags
-#   - modified February 2012
+#   - February 2012
 #     [+] updated for NDK r7b
 #     [~] fixed cmake try_compile() command
 #     [~] Fix for missing install_name_tool on OS X
-#   - modified March 2012
+#   - March 2012
 #     [~] fixed incorrect C compiler flags
 #     [~] fixed CMAKE_SYSTEM_PROCESSOR change on ANDROID_ABI change
 #     [+] improved toolchain loading speed
 #     [+] added assembler language support (.S)
 #     [+] allowed preset search paths and extra search suffixes
-#   - modified April 2012
+#   - April 2012
 #     [+] updated for NDK r7c
 #     [~] fixed most of problems with compiler/linker flags and caching
 #     [+] added option ANDROID_FUNCTION_LEVEL_LINKING
-#   - modified May 2012
+#   - May 2012
 #     [+] updated for NDK r8
 #     [+] added mips architecture support
-#   - modified August 2012
+#   - August 2012
 #     [+] updated for NDK r8b
 #     [~] all intermediate files generated by toolchain are moved to CMakeFiles
 #     [~] libstdc++ and libsupc are removed from explicit link libraries
 #     [+] added CCache support (via NDK_CCACHE environment or cmake variable)
 #     [+] added gold linker support for NDK r8b
 #     [~] fixed mips linker flags for NDK r8b
-#   - modified September 2012
+#   - September 2012
 #     [+] added NDK release name detection (see ANDROID_NDK_RELEASE)
 #     [+] added support for all C++ runtimes from NDK
 #         (system, gabi++, stlport, gnustl)
@@ -235,8 +275,11 @@
 #     [~] use gold linker as default if available (NDK r8b)
 #     [~] globally turned off rpath
 #     [~] compiler options are aligned with NDK r8b
-#   - modified October 2012
+#   - October 2012
 #     [~] fixed C++ linking: explicitly link with math library (OpenCV #2426)
+#   - November 2012
+#     [+] updated for NDK r8c
+#     [+] added support for clang compiler
 # ------------------------------------------------------------------------------
 
 cmake_minimum_required( VERSION 2.6.3 )
@@ -259,7 +302,7 @@ set( CMAKE_SYSTEM_VERSION 1 )
 # rpath makes low sence for Android
 set( CMAKE_SKIP_RPATH TRUE CACHE BOOL "If set, runtime paths are not added when using shared libraries." )
 
-set( ANDROID_SUPPORTED_NDK_VERSIONS ${ANDROID_EXTRA_NDK_VERSIONS} -r8b -r8 -r7c -r7b -r7 -r6b -r6 -r5c -r5b -r5 "" )
+set( ANDROID_SUPPORTED_NDK_VERSIONS ${ANDROID_EXTRA_NDK_VERSIONS} -r8c -r8b -r8 -r7c -r7b -r7 -r6b -r6 -r5c -r5b -r5 "" )
 if(NOT DEFINED ANDROID_NDK_SEARCH_PATHS)
  if( CMAKE_HOST_WIN32 )
   file( TO_CMAKE_PATH "$ENV{PROGRAMFILES}" ANDROID_NDK_SEARCH_PATHS )
@@ -367,8 +410,8 @@ endmacro()
 
 macro( __DETECT_TOOLCHAIN_MACHINE_NAME _var _root )
  if( EXISTS "${_root}" )
-  file( GLOB __gccExePath "${_root}/bin/*-gcc${TOOL_OS_SUFFIX}" )
-  __LIST_FILTER( __gccExePath "bin/[.].*-gcc${TOOL_OS_SUFFIX}$" )
+  file( GLOB __gccExePath RELATIVE "${_root}/bin/" "${_root}/bin/*-gcc${TOOL_OS_SUFFIX}" )
+  __LIST_FILTER( __gccExePath "^[.].*" )
   list( LENGTH __gccExePath __gccExePathsCount )
   if( NOT __gccExePathsCount EQUAL 1  AND NOT _CMAKE_IN_TRY_COMPILE )
    message( WARNING "Could not determine machine name for compiler from ${_root}" )
@@ -506,55 +549,76 @@ if( BUILD_WITH_STANDALONE_TOOLCHAIN )
  elseif( __availableToolchainMachines MATCHES mipsel )
   set( __availableToolchainArchs "mipsel" )
  endif()
- if( ANDROID_COMPILER_VERSION )
-  # do not run gcc every time because it is relatevely expencive
-  set( __availableToolchainCompilerVersions "${ANDROID_COMPILER_VERSION}" )
- else()
-  execute_process( COMMAND "${ANDROID_STANDALONE_TOOLCHAIN}/bin/${__availableToolchainMachines}-gcc${TOOL_OS_SUFFIX}" --version
-   OUTPUT_VARIABLE __availableToolchainCompilerVersions OUTPUT_STRIP_TRAILING_WHITESPACE )
-  string( REGEX MATCH "[0-9]+[.][0-9]+([.][0-9]+)?" __availableToolchainCompilerVersions "${__availableToolchainCompilerVersions}" )
+ execute_process( COMMAND "${ANDROID_STANDALONE_TOOLCHAIN}/bin/${__availableToolchainMachines}-gcc${TOOL_OS_SUFFIX}" -dumpversion
+                  OUTPUT_VARIABLE __availableToolchainCompilerVersions OUTPUT_STRIP_TRAILING_WHITESPACE )
+ string( REGEX MATCH "[0-9]+[.][0-9]+([.][0-9]+)?" __availableToolchainCompilerVersions "${__availableToolchainCompilerVersions}" )
+ if( EXISTS "${ANDROID_STANDALONE_TOOLCHAIN}/bin/clang${TOOL_OS_SUFFIX}" )
+  list( APPEND __availableToolchains "standalone-clang" )
+  list( APPEND __availableToolchainMachines ${__availableToolchainMachines} )
+  list( APPEND __availableToolchainArchs ${__availableToolchainArchs} )
+  list( APPEND __availableToolchainCompilerVersions ${__availableToolchainCompilerVersions} )
  endif()
 endif()
 
+macro( __GLOB_NDK_TOOLCHAINS __availableToolchainsVar )
+ foreach( __toolchain ${${__availableToolchainsVar}} )
+  if( "${__toolchain}" MATCHES "-clang3[.][0-9]$" AND NOT EXISTS "${ANDROID_NDK}/toolchains/${__toolchain}/prebuilt/" )
+   string( REGEX REPLACE "-clang3[.][0-9]$" "-4.6" __gcc_toolchain "${__toolchain}" )
+  else()
+   set( __gcc_toolchain "${__toolchain}" )
+  endif()
+  __DETECT_TOOLCHAIN_MACHINE_NAME( __machine "${ANDROID_NDK}/toolchains/${__gcc_toolchain}/prebuilt/${ANDROID_NDK_HOST_SYSTEM_NAME}" )
+  if( __machine )
+   string( REGEX MATCH "[0-9]+[.][0-9]+([.][0-9]+)?$" __version "${__gcc_toolchain}" )
+   string( REGEX MATCH "^[^-]+" __arch "${__gcc_toolchain}" )
+   list( APPEND __availableToolchainMachines "${__machine}" )
+   list( APPEND __availableToolchainArchs "${__arch}" )
+   list( APPEND __availableToolchainCompilerVersions "${__version}" )
+  else()
+   list( REMOVE_ITEM ${__availableToolchainsVar} "${__toolchain}" )
+  endif()
+  unset( __gcc_toolchain )
+ endforeach()
+endmacro()
+
 # get all the details about NDK
 if( BUILD_WITH_ANDROID_NDK )
  file( GLOB ANDROID_SUPPORTED_NATIVE_API_LEVELS RELATIVE "${ANDROID_NDK}/platforms" "${ANDROID_NDK}/platforms/android-*" )
  string( REPLACE "android-" "" ANDROID_SUPPORTED_NATIVE_API_LEVELS "${ANDROID_SUPPORTED_NATIVE_API_LEVELS}" )
- file( GLOB __availableToolchains RELATIVE "${ANDROID_NDK}/toolchains" "${ANDROID_NDK}/toolchains/*" )
- __LIST_FILTER( __availableToolchains "^[.]" )
+ set( __availableToolchains "" )
  set( __availableToolchainMachines "" )
  set( __availableToolchainArchs "" )
  set( __availableToolchainCompilerVersions "" )
- foreach( __toolchain ${__availableToolchains} )
-  __DETECT_TOOLCHAIN_MACHINE_NAME( __machine "${ANDROID_NDK}/toolchains/${__toolchain}/prebuilt/${ANDROID_NDK_HOST_SYSTEM_NAME}" )
-  if( __machine )
-   string( REGEX MATCH "[0-9]+[.][0-9]+([.][0-9]+)?$" __version "${__toolchain}" )
-   string( REGEX MATCH "^[^-]+" __arch "${__toolchain}" )
-   list( APPEND __availableToolchainMachines "${__machine}" )
-   list( APPEND __availableToolchainArchs "${__arch}" )
-   list( APPEND __availableToolchainCompilerVersions "${__version}" )
-  else()
-   list( REMOVE_ITEM __availableToolchains "${__toolchain}" )
-  endif()
- endforeach()
+ if( ANDROID_TOOLCHAIN_NAME AND EXISTS "${ANDROID_NDK}/toolchains/${ANDROID_TOOLCHAIN_NAME}/" )
+  # do not go through all toolchains if we know the name
+  set( __availableToolchains "${ANDROID_TOOLCHAIN_NAME}" )
+  __GLOB_NDK_TOOLCHAINS( __availableToolchains )
+ endif()
  if( NOT __availableToolchains )
-  message( FATAL_ERROR "Could not any working toolchain in the NDK. Probably your Android NDK is broken." )
+  file( GLOB __availableToolchains RELATIVE "${ANDROID_NDK}/toolchains" "${ANDROID_NDK}/toolchains/*" )
+  if( __availableToolchains )
+   list(SORT __availableToolchains) # we need clang to go after gcc
+  endif()
+  __LIST_FILTER( __availableToolchains "^[.]" )
+  __LIST_FILTER( __availableToolchains "llvm" )
+  __GLOB_NDK_TOOLCHAINS( __availableToolchains )
+ endif()
+ if( NOT __availableToolchains )
+  message( FATAL_ERROR "Could not find any working toolchain in the NDK. Probably your Android NDK is broken." )
  endif()
 endif()
 
 # build list of available ABIs
+set( ANDROID_SUPPORTED_ABIS "" )
+set( __uniqToolchainArchNames ${__availableToolchainArchs} )
+list( REMOVE_DUPLICATES __uniqToolchainArchNames )
+list( SORT __uniqToolchainArchNames )
+foreach( __arch ${__uniqToolchainArchNames} )
+list( APPEND ANDROID_SUPPORTED_ABIS ${ANDROID_SUPPORTED_ABIS_${__arch}} )
+endforeach()
+unset( __uniqToolchainArchNames )
 if( NOT ANDROID_SUPPORTED_ABIS )
- set( ANDROID_SUPPORTED_ABIS "" )
- set( __uniqToolchainArchNames ${__availableToolchainArchs} )
- list( REMOVE_DUPLICATES __uniqToolchainArchNames )
- list( SORT __uniqToolchainArchNames )
- foreach( __arch ${__uniqToolchainArchNames} )
-  list( APPEND ANDROID_SUPPORTED_ABIS ${ANDROID_SUPPORTED_ABIS_${__arch}} )
- endforeach()
- unset( __uniqToolchainArchNames )
- if( NOT ANDROID_SUPPORTED_ABIS )
-  message( FATAL_ERROR "No one of known Android ABIs is supported by this cmake toolchain." )
- endif()
+message( FATAL_ERROR "No one of known Android ABIs is supported by this cmake toolchain." )
 endif()
 
 # choose target ABI
@@ -569,33 +633,34 @@ if( __androidAbiIdx EQUAL -1 )
 endif()
 unset( __androidAbiIdx )
 
-# remember target ABI
-set( ANDROID_ABI "${ANDROID_ABI}" CACHE STRING "The target ABI for Android. If arm, then armeabi-v7a is recommended for hardware floating point." FORCE )
-
 # set target ABI options
 if( ANDROID_ABI STREQUAL "x86" )
  set( X86 true )
  set( ANDROID_NDK_ABI_NAME "x86" )
  set( ANDROID_ARCH_NAME "x86" )
  set( ANDROID_ARCH_FULLNAME "x86" )
+ set( ANDROID_LLVM_TRIPLE "i686-none-linux-android" )
  set( CMAKE_SYSTEM_PROCESSOR "i686" )
 elseif( ANDROID_ABI STREQUAL "mips" )
  set( MIPS true )
  set( ANDROID_NDK_ABI_NAME "mips" )
  set( ANDROID_ARCH_NAME "mips" )
  set( ANDROID_ARCH_FULLNAME "mipsel" )
+ set( ANDROID_LLVM_TRIPLE "mipsel-none-linux-android" )
  set( CMAKE_SYSTEM_PROCESSOR "mips" )
 elseif( ANDROID_ABI STREQUAL "armeabi" )
  set( ARMEABI true )
  set( ANDROID_NDK_ABI_NAME "armeabi" )
  set( ANDROID_ARCH_NAME "arm" )
  set( ANDROID_ARCH_FULLNAME "arm" )
+ set( ANDROID_LLVM_TRIPLE "armv5te-none-linux-androideabi" )
  set( CMAKE_SYSTEM_PROCESSOR "armv5te" )
 elseif( ANDROID_ABI STREQUAL "armeabi-v6 with VFP" )
  set( ARMEABI_V6 true )
  set( ANDROID_NDK_ABI_NAME "armeabi" )
  set( ANDROID_ARCH_NAME "arm" )
  set( ANDROID_ARCH_FULLNAME "arm" )
+ set( ANDROID_LLVM_TRIPLE "armv5te-none-linux-androideabi" )
  set( CMAKE_SYSTEM_PROCESSOR "armv6" )
  # need always fallback to older platform
  set( ARMEABI true )
@@ -604,12 +669,14 @@ elseif( ANDROID_ABI STREQUAL "armeabi-v7a")
  set( ANDROID_NDK_ABI_NAME "armeabi-v7a" )
  set( ANDROID_ARCH_NAME "arm" )
  set( ANDROID_ARCH_FULLNAME "arm" )
+ set( ANDROID_LLVM_TRIPLE "armv7-none-linux-androideabi" )
  set( CMAKE_SYSTEM_PROCESSOR "armv7-a" )
 elseif( ANDROID_ABI STREQUAL "armeabi-v7a with VFPV3" )
  set( ARMEABI_V7A true )
  set( ANDROID_NDK_ABI_NAME "armeabi-v7a" )
  set( ANDROID_ARCH_NAME "arm" )
  set( ANDROID_ARCH_FULLNAME "arm" )
+ set( ANDROID_LLVM_TRIPLE "armv7-none-linux-androideabi" )
  set( CMAKE_SYSTEM_PROCESSOR "armv7-a" )
  set( VFPV3 true )
 elseif( ANDROID_ABI STREQUAL "armeabi-v7a with NEON" )
@@ -617,6 +684,7 @@ elseif( ANDROID_ABI STREQUAL "armeabi-v7a with NEON" )
  set( ANDROID_NDK_ABI_NAME "armeabi-v7a" )
  set( ANDROID_ARCH_NAME "arm" )
  set( ANDROID_ARCH_FULLNAME "arm" )
+ set( ANDROID_LLVM_TRIPLE "armv7-none-linux-androideabi" )
  set( CMAKE_SYSTEM_PROCESSOR "armv7-a" )
  set( VFPV3 true )
  set( NEON true )
@@ -630,12 +698,6 @@ if( CMAKE_BINARY_DIR AND EXISTS "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMa
  file( APPEND "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeSystem.cmake" "SET(CMAKE_SYSTEM_PROCESSOR \"${CMAKE_SYSTEM_PROCESSOR}\")\n" )
 endif()
 
-set( ANDROID_SUPPORTED_ABIS ${ANDROID_SUPPORTED_ABIS_${ANDROID_ARCH_FULLNAME}} CACHE INTERNAL "ANDROID_ABI can be changed only to one of these ABIs. Changing to any other ABI requires to reset cmake cache." FORCE )
-if( CMAKE_VERSION VERSION_GREATER "2.8" )
- list( SORT ANDROID_SUPPORTED_ABIS_${ANDROID_ARCH_FULLNAME} )
- set_property( CACHE ANDROID_ABI PROPERTY STRINGS ${ANDROID_SUPPORTED_ABIS_${ANDROID_ARCH_FULLNAME}} )
-endif()
-
 if( ANDROID_ARCH_NAME STREQUAL "arm" AND NOT ARMEABI_V6 )
  __INIT_VARIABLE( ANDROID_FORCE_ARM_BUILD OBSOLETE_FORCE_ARM VALUES OFF )
  set( ANDROID_FORCE_ARM_BUILD ${ANDROID_FORCE_ARM_BUILD} CACHE BOOL "Use 32-bit ARM instructions instead of Thumb-1" FORCE )
@@ -648,11 +710,15 @@ endif()
 if( ANDROID_TOOLCHAIN_NAME )
  list( FIND __availableToolchains "${ANDROID_TOOLCHAIN_NAME}" __toolchainIdx )
  if( __toolchainIdx EQUAL -1 )
-  message( FATAL_ERROR "Previously selected toolchain \"${ANDROID_TOOLCHAIN_NAME}\" is missing. You need to remove CMakeCache.txt and rerun cmake manually to change the toolchain" )
+  list( SORT __availableToolchains )
+  string( REPLACE ";" "\n  * " toolchains_list "${__availableToolchains}" )
+  set( toolchains_list "  * ${toolchains_list}")
+  message( FATAL_ERROR "Specified toolchain \"${ANDROID_TOOLCHAIN_NAME}\" is missing in your NDK or broken. Please verify that your NDK is working or select another compiler toolchain.
+To configure the toolchain set CMake variable ANDROID_TOOLCHAIN_NAME to one of the following values:\n${toolchains_list}\n" )
  endif()
  list( GET __availableToolchainArchs ${__toolchainIdx} __toolchainArch )
  if( NOT __toolchainArch STREQUAL ANDROID_ARCH_FULLNAME )
-  message( SEND_ERROR "Previously selected toolchain \"${ANDROID_TOOLCHAIN_NAME}\" is not able to compile binaries for the \"${ANDROID_ARCH_NAME}\" platform." )
+  message( SEND_ERROR "Selected toolchain \"${ANDROID_TOOLCHAIN_NAME}\" is not able to compile binaries for the \"${ANDROID_ARCH_NAME}\" platform." )
  endif()
 else()
  set( __toolchainIdx -1 )
@@ -681,8 +747,7 @@ endif()
 list( GET __availableToolchains ${__toolchainIdx} ANDROID_TOOLCHAIN_NAME )
 list( GET __availableToolchainMachines ${__toolchainIdx} ANDROID_TOOLCHAIN_MACHINE_NAME )
 list( GET __availableToolchainCompilerVersions ${__toolchainIdx} ANDROID_COMPILER_VERSION )
-set( ANDROID_TOOLCHAIN_NAME "${ANDROID_TOOLCHAIN_NAME}" CACHE INTERNAL "Name of toolchain used" FORCE )
-set( ANDROID_COMPILER_VERSION "${ANDROID_COMPILER_VERSION}" CACHE INTERNAL "compiler version from selected toolchain" FORCE )
+
 unset( __toolchainIdx )
 unset( __availableToolchains )
 unset( __availableToolchainMachines )
@@ -692,37 +757,35 @@ unset( __availableToolchainCompilerVersions )
 # choose native API level
 __INIT_VARIABLE( ANDROID_NATIVE_API_LEVEL ENV_ANDROID_NATIVE_API_LEVEL ANDROID_API_LEVEL ENV_ANDROID_API_LEVEL ANDROID_STANDALONE_TOOLCHAIN_API_LEVEL ANDROID_DEFAULT_NDK_API_LEVEL_${ANDROID_ARCH_NAME} ANDROID_DEFAULT_NDK_API_LEVEL )
 string( REGEX MATCH "[0-9]+" ANDROID_NATIVE_API_LEVEL "${ANDROID_NATIVE_API_LEVEL}" )
+# TODO: filter out unsupported levels
 # validate
 list( FIND ANDROID_SUPPORTED_NATIVE_API_LEVELS "${ANDROID_NATIVE_API_LEVEL}" __levelIdx )
 if( __levelIdx EQUAL -1 )
  message( SEND_ERROR "Specified Android native API level (${ANDROID_NATIVE_API_LEVEL}) is not supported by your NDK/toolchain." )
+else()
+ if( BUILD_WITH_ANDROID_NDK )
+  __DETECT_NATIVE_API_LEVEL( __realApiLevel "${ANDROID_NDK}/platforms/android-${ANDROID_NATIVE_API_LEVEL}/arch-${ANDROID_ARCH_NAME}/usr/include/android/api-level.h" )
+  if( NOT __realApiLevel EQUAL ANDROID_NATIVE_API_LEVEL )
+   message( SEND_ERROR "Specified Android API level (${ANDROID_NATIVE_API_LEVEL}) does not match to the level found (${__realApiLevel}). Probably your copy of NDK is broken." )
+  endif()
+  unset( __realApiLevel )
+ endif()
+ set( ANDROID_NATIVE_API_LEVEL "${ANDROID_NATIVE_API_LEVEL}" CACHE STRING "Android API level for native code" FORCE )
+ if( CMAKE_VERSION VERSION_GREATER "2.8" )
+  list( SORT ANDROID_SUPPORTED_NATIVE_API_LEVELS )
+  set_property( CACHE ANDROID_NATIVE_API_LEVEL PROPERTY STRINGS ${ANDROID_SUPPORTED_NATIVE_API_LEVELS} )
+ endif()
 endif()
 unset( __levelIdx )
-if( BUILD_WITH_ANDROID_NDK )
- __DETECT_NATIVE_API_LEVEL( __realApiLevel "${ANDROID_NDK}/platforms/android-${ANDROID_NATIVE_API_LEVEL}/arch-${ANDROID_ARCH_NAME}/usr/include/android/api-level.h" )
- if( NOT __realApiLevel EQUAL ANDROID_NATIVE_API_LEVEL )
-  message( SEND_ERROR "Specified Android API level (${ANDROID_NATIVE_API_LEVEL}) does not match to the level found (${__realApiLevel}). Probably your copy of NDK is broken." )
- endif()
- unset( __realApiLevel )
-endif()
-set( ANDROID_NATIVE_API_LEVEL "${ANDROID_NATIVE_API_LEVEL}" CACHE STRING "Android API level for native code" FORCE )
+
+
+# remember target ABI
+set( ANDROID_ABI "${ANDROID_ABI}" CACHE STRING "The target ABI for Android. If arm, then armeabi-v7a is recommended for hardware floating point." FORCE )
 if( CMAKE_VERSION VERSION_GREATER "2.8" )
- list( SORT ANDROID_SUPPORTED_NATIVE_API_LEVELS )
- set_property( CACHE ANDROID_NATIVE_API_LEVEL PROPERTY STRINGS ${ANDROID_SUPPORTED_NATIVE_API_LEVELS} )
+ list( SORT ANDROID_SUPPORTED_ABIS_${ANDROID_ARCH_FULLNAME} )
+ set_property( CACHE ANDROID_ABI PROPERTY STRINGS ${ANDROID_SUPPORTED_ABIS_${ANDROID_ARCH_FULLNAME}} )
 endif()
 
-# setup output directories
-set( LIBRARY_OUTPUT_PATH_ROOT ${CMAKE_SOURCE_DIR} CACHE PATH "root for library output, set this to change where android libs are installed to" )
-set( CMAKE_INSTALL_PREFIX "${ANDROID_TOOLCHAIN_ROOT}/user" CACHE STRING "path for installing" )
-
-if(NOT _CMAKE_IN_TRY_COMPILE)
- if( EXISTS "${CMAKE_SOURCE_DIR}/jni/CMakeLists.txt" )
-  set( EXECUTABLE_OUTPUT_PATH "${LIBRARY_OUTPUT_PATH_ROOT}/bin/${ANDROID_NDK_ABI_NAME}" CACHE PATH "Output directory for applications" )
- else()
-  set( EXECUTABLE_OUTPUT_PATH "${LIBRARY_OUTPUT_PATH_ROOT}/bin" CACHE PATH "Output directory for applications" )
- endif()
- set( LIBRARY_OUTPUT_PATH "${LIBRARY_OUTPUT_PATH_ROOT}/libs/${ANDROID_NDK_ABI_NAME}" CACHE PATH "path for android libs" )
-endif()
 
 # runtime choice (STL, rtti, exceptions)
 if( NOT ANDROID_STL )
@@ -800,9 +863,84 @@ See https://android.googlesource.com/platform/development.git f907f4f9d4e56ccc80
 " )
 endif()
 
+
+# setup paths and STL for standalone toolchain
+if( BUILD_WITH_STANDALONE_TOOLCHAIN )
+ set( ANDROID_TOOLCHAIN_ROOT "${ANDROID_STANDALONE_TOOLCHAIN}" )
+ set( ANDROID_CLANG_TOOLCHAIN_ROOT "${ANDROID_STANDALONE_TOOLCHAIN}" )
+ set( ANDROID_SYSROOT "${ANDROID_STANDALONE_TOOLCHAIN}/sysroot" )
+
+ if( NOT ANDROID_STL STREQUAL "none" )
+  set( ANDROID_STL_INCLUDE_DIRS "${ANDROID_STANDALONE_TOOLCHAIN}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/include/c++/${ANDROID_COMPILER_VERSION}" )
+  if( ARMEABI_V7A AND EXISTS "${ANDROID_STL_INCLUDE_DIRS}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/${CMAKE_SYSTEM_PROCESSOR}/bits" )
+   list( APPEND ANDROID_STL_INCLUDE_DIRS "${ANDROID_STL_INCLUDE_DIRS}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/${CMAKE_SYSTEM_PROCESSOR}" )
+  elseif( ARMEABI AND NOT ANDROID_FORCE_ARM_BUILD AND EXISTS "${ANDROID_STL_INCLUDE_DIRS}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/thumb/bits" )
+   list( APPEND ANDROID_STL_INCLUDE_DIRS "${ANDROID_STL_INCLUDE_DIRS}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/thumb" )
+  else()
+   list( APPEND ANDROID_STL_INCLUDE_DIRS "${ANDROID_STL_INCLUDE_DIRS}/${ANDROID_TOOLCHAIN_MACHINE_NAME}" )
+  endif()
+  # always search static GNU STL to get the location of libsupc++.a
+  if( ARMEABI_V7A AND NOT ANDROID_FORCE_ARM_BUILD AND EXISTS "${ANDROID_STANDALONE_TOOLCHAIN}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib/${CMAKE_SYSTEM_PROCESSOR}/thumb/libstdc++.a" )
+   set( __libstl "${ANDROID_STANDALONE_TOOLCHAIN}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib/${CMAKE_SYSTEM_PROCESSOR}/thumb" )
+  elseif( ARMEABI_V7A AND EXISTS "${ANDROID_STANDALONE_TOOLCHAIN}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib/${CMAKE_SYSTEM_PROCESSOR}/libstdc++.a" )
+   set( __libstl "${ANDROID_STANDALONE_TOOLCHAIN}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib/${CMAKE_SYSTEM_PROCESSOR}" )
+  elseif( ARMEABI AND NOT ANDROID_FORCE_ARM_BUILD AND EXISTS "${ANDROID_STANDALONE_TOOLCHAIN}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib/thumb/libstdc++.a" )
+   set( __libstl "${ANDROID_STANDALONE_TOOLCHAIN}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib/thumb" )
+  elseif( EXISTS "${ANDROID_STANDALONE_TOOLCHAIN}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib/libstdc++.a" )
+   set( __libstl "${ANDROID_STANDALONE_TOOLCHAIN}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib" )
+  endif()
+  if( __libstl )
+   set( __libsupcxx "${__libstl}/libsupc++.a" )
+   set( __libstl    "${__libstl}/libstdc++.a" )
+  endif()
+  if( NOT EXISTS "${__libsupcxx}" )
+   message( FATAL_ERROR "The required libstdsupc++.a is missing in your standalone toolchain.
+ Usually it happens because of bug in make-standalone-toolchain.sh script from NDK r7, r7b and r7c.
+ You need to either upgrade to newer NDK or manually copy
+     $ANDROID_NDK/sources/cxx-stl/gnu-libstdc++/libs/${ANDROID_NDK_ABI_NAME}/libsupc++.a
+ to
+     ${__libsupcxx}
+   " )
+  endif()
+  if( ANDROID_STL STREQUAL "gnustl_shared" )
+   if( ARMEABI_V7A AND EXISTS "${ANDROID_STANDALONE_TOOLCHAIN}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib/${CMAKE_SYSTEM_PROCESSOR}/libgnustl_shared.so" )
+    set( __libstl "${ANDROID_STANDALONE_TOOLCHAIN}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib/${CMAKE_SYSTEM_PROCESSOR}/libgnustl_shared.so" )
+   elseif( ARMEABI AND NOT ANDROID_FORCE_ARM_BUILD AND EXISTS "${ANDROID_STANDALONE_TOOLCHAIN}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib/thumb/libgnustl_shared.so" )
+    set( __libstl "${ANDROID_STANDALONE_TOOLCHAIN}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib/thumb/libgnustl_shared.so" )
+   elseif( EXISTS "${ANDROID_STANDALONE_TOOLCHAIN}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib/libgnustl_shared.so" )
+    set( __libstl "${ANDROID_STANDALONE_TOOLCHAIN}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib/libgnustl_shared.so" )
+   endif()
+  endif()
+ endif()
+endif()
+
+# clang
+if( "${ANDROID_TOOLCHAIN_NAME}" STREQUAL "standalone-clang" )
+ set( ANDROID_COMPILER_IS_CLANG 1 )
+ execute_process( COMMAND "${ANDROID_CLANG_TOOLCHAIN_ROOT}/bin/clang${TOOL_OS_SUFFIX}" --version OUTPUT_VARIABLE ANDROID_CLANG_VERSION OUTPUT_STRIP_TRAILING_WHITESPACE )
+ string( REGEX MATCH "[0-9]+[.][0-9]+" ANDROID_CLANG_VERSION "${ANDROID_CLANG_VERSION}")
+elseif( "${ANDROID_TOOLCHAIN_NAME}" MATCHES "-clang3[.][0-9]?$" )
+ string( REGEX MATCH "3[.][0-9]$" ANDROID_CLANG_VERSION "${ANDROID_TOOLCHAIN_NAME}")
+ string( REGEX REPLACE "-clang${ANDROID_CLANG_VERSION}$" "-4.6" ANDROID_GCC_TOOLCHAIN_NAME "${ANDROID_TOOLCHAIN_NAME}" )
+ if( NOT EXISTS "${ANDROID_NDK}/toolchains/llvm-${ANDROID_CLANG_VERSION}/prebuilt/${ANDROID_NDK_HOST_SYSTEM_NAME}/bin/clang${TOOL_OS_SUFFIX}" )
+  message( FATAL_ERROR "Could not find the " )
+ endif()
+ set( ANDROID_COMPILER_IS_CLANG 1 )
+ set( ANDROID_CLANG_TOOLCHAIN_ROOT "${ANDROID_NDK}/toolchains/llvm-${ANDROID_CLANG_VERSION}/prebuilt/${ANDROID_NDK_HOST_SYSTEM_NAME}" )
+else()
+ set( ANDROID_GCC_TOOLCHAIN_NAME "${ANDROID_TOOLCHAIN_NAME}" )
+ unset( ANDROID_COMPILER_IS_CLANG CACHE )
+endif()
+
+string( REPLACE "." "" _clang_name "clang${ANDROID_CLANG_VERSION}" )
+if( NOT EXISTS "${ANDROID_CLANG_TOOLCHAIN_ROOT}/bin/${_clang_name}${TOOL_OS_SUFFIX}" )
+ set( _clang_name "clang" )
+endif()
+
+
 # setup paths and STL for NDK
 if( BUILD_WITH_ANDROID_NDK )
- set( ANDROID_TOOLCHAIN_ROOT "${ANDROID_NDK}/toolchains/${ANDROID_TOOLCHAIN_NAME}/prebuilt/${ANDROID_NDK_HOST_SYSTEM_NAME}" )
+ set( ANDROID_TOOLCHAIN_ROOT "${ANDROID_NDK}/toolchains/${ANDROID_GCC_TOOLCHAIN_NAME}/prebuilt/${ANDROID_NDK_HOST_SYSTEM_NAME}" )
  set( ANDROID_SYSROOT "${ANDROID_NDK}/platforms/android-${ANDROID_NATIVE_API_LEVEL}/arch-${ANDROID_ARCH_NAME}" )
 
  if( ANDROID_STL STREQUAL "none" )
@@ -874,54 +1012,6 @@ if( BUILD_WITH_ANDROID_NDK )
  endif()
 endif()
 
-# setup paths and STL for standalone toolchain
-if( BUILD_WITH_STANDALONE_TOOLCHAIN )
- set( ANDROID_TOOLCHAIN_ROOT "${ANDROID_STANDALONE_TOOLCHAIN}" )
- set( ANDROID_SYSROOT "${ANDROID_STANDALONE_TOOLCHAIN}/sysroot" )
-
- if( NOT ANDROID_STL STREQUAL "none" )
-  set( ANDROID_STL_INCLUDE_DIRS "${ANDROID_STANDALONE_TOOLCHAIN}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/include/c++/${ANDROID_COMPILER_VERSION}" )
-  if( ARMEABI_V7A AND EXISTS "${ANDROID_STL_INCLUDE_DIRS}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/${CMAKE_SYSTEM_PROCESSOR}/bits" )
-   list( APPEND ANDROID_STL_INCLUDE_DIRS "${ANDROID_STL_INCLUDE_DIRS}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/${CMAKE_SYSTEM_PROCESSOR}" )
-  elseif( ARMEABI AND NOT ANDROID_FORCE_ARM_BUILD AND EXISTS "${ANDROID_STL_INCLUDE_DIRS}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/thumb/bits" )
-   list( APPEND ANDROID_STL_INCLUDE_DIRS "${ANDROID_STL_INCLUDE_DIRS}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/thumb" )
-  else()
-   list( APPEND ANDROID_STL_INCLUDE_DIRS "${ANDROID_STL_INCLUDE_DIRS}/${ANDROID_TOOLCHAIN_MACHINE_NAME}" )
-  endif()
-  # always search static GNU STL to get the location of libsupc++.a
-  if( ARMEABI_V7A AND NOT ANDROID_FORCE_ARM_BUILD AND EXISTS "${ANDROID_STANDALONE_TOOLCHAIN}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib/${CMAKE_SYSTEM_PROCESSOR}/thumb/libstdc++.a" )
-   set( __libstl "${ANDROID_STANDALONE_TOOLCHAIN}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib/${CMAKE_SYSTEM_PROCESSOR}/thumb" )
-  elseif( ARMEABI_V7A AND EXISTS "${ANDROID_STANDALONE_TOOLCHAIN}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib/${CMAKE_SYSTEM_PROCESSOR}/libstdc++.a" )
-   set( __libstl "${ANDROID_STANDALONE_TOOLCHAIN}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib/${CMAKE_SYSTEM_PROCESSOR}" )
-  elseif( ARMEABI AND NOT ANDROID_FORCE_ARM_BUILD AND EXISTS "${ANDROID_STANDALONE_TOOLCHAIN}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib/thumb/libstdc++.a" )
-   set( __libstl "${ANDROID_STANDALONE_TOOLCHAIN}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib/thumb" )
-  elseif( EXISTS "${ANDROID_STANDALONE_TOOLCHAIN}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib/libstdc++.a" )
-   set( __libstl "${ANDROID_STANDALONE_TOOLCHAIN}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib" )
-  endif()
-  if( __libstl )
-   set( __libsupcxx "${__libstl}/libsupc++.a" )
-   set( __libstl    "${__libstl}/libstdc++.a" )
-  endif()
-  if( NOT EXISTS "${__libsupcxx}" )
-   message( FATAL_ERROR "The required libstdsupc++.a is missing in your standalone toolchain.
- Usually it happens because of bug in make-standalone-toolchain.sh script from NDK r7, r7b and r7c.
- You need to either upgrade to newer NDK or manually copy
-     $ANDROID_NDK/sources/cxx-stl/gnu-libstdc++/libs/${ANDROID_NDK_ABI_NAME}/libsupc++.a
- to
-     ${__libsupcxx}
-   " )
-  endif()
-  if( ANDROID_STL STREQUAL "gnustl_shared" )
-   if( ARMEABI_V7A AND EXISTS "${ANDROID_STANDALONE_TOOLCHAIN}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib/${CMAKE_SYSTEM_PROCESSOR}/libgnustl_shared.so" )
-    set( __libstl "${ANDROID_STANDALONE_TOOLCHAIN}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib/${CMAKE_SYSTEM_PROCESSOR}/libgnustl_shared.so" )
-   elseif( ARMEABI AND NOT ANDROID_FORCE_ARM_BUILD AND EXISTS "${ANDROID_STANDALONE_TOOLCHAIN}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib/thumb/libgnustl_shared.so" )
-    set( __libstl "${ANDROID_STANDALONE_TOOLCHAIN}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib/thumb/libgnustl_shared.so" )
-   elseif( EXISTS "${ANDROID_STANDALONE_TOOLCHAIN}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib/libgnustl_shared.so" )
-    set( __libstl "${ANDROID_STANDALONE_TOOLCHAIN}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib/libgnustl_shared.so" )
-   endif()
-  endif()
- endif()
-endif()
 
 # case of shared STL linkage
 if( ANDROID_STL MATCHES "shared" AND DEFINED __libstl )
@@ -937,6 +1027,7 @@ if( ANDROID_STL MATCHES "shared" AND DEFINED __libstl )
  endif()
 endif()
 
+
 # ccache support
 __INIT_VARIABLE( _ndk_ccache NDK_CCACHE ENV_NDK_CCACHE )
 if( _ndk_ccache )
@@ -946,16 +1037,27 @@ else()
 endif()
 unset( _ndk_ccache )
 
+
 # setup the cross-compiler
 if( NOT CMAKE_C_COMPILER )
  if( NDK_CCACHE )
   set( CMAKE_C_COMPILER   "${NDK_CCACHE}" CACHE PATH "ccache as C compiler" )
   set( CMAKE_CXX_COMPILER "${NDK_CCACHE}" CACHE PATH "ccache as C++ compiler" )
-  set( CMAKE_C_COMPILER_ARG1 "${ANDROID_TOOLCHAIN_ROOT}/bin/${ANDROID_TOOLCHAIN_MACHINE_NAME}-gcc${TOOL_OS_SUFFIX}"   CACHE PATH "gcc")
-  set( CMAKE_CXX_COMPILER_ARG1 "${ANDROID_TOOLCHAIN_ROOT}/bin/${ANDROID_TOOLCHAIN_MACHINE_NAME}-g++${TOOL_OS_SUFFIX}" CACHE PATH "g++")
+  if( ANDROID_COMPILER_IS_CLANG )
+   set( CMAKE_C_COMPILER_ARG1   "${ANDROID_CLANG_TOOLCHAIN_ROOT}/bin/${_clang_name}${TOOL_OS_SUFFIX}"   CACHE PATH "C compiler")
+   set( CMAKE_CXX_COMPILER_ARG1 "${ANDROID_CLANG_TOOLCHAIN_ROOT}/bin/${_clang_name}++${TOOL_OS_SUFFIX}" CACHE PATH "C++ compiler")
+  else()
+   set( CMAKE_C_COMPILER_ARG1   "${ANDROID_TOOLCHAIN_ROOT}/bin/${ANDROID_TOOLCHAIN_MACHINE_NAME}-gcc${TOOL_OS_SUFFIX}" CACHE PATH "C compiler")
+   set( CMAKE_CXX_COMPILER_ARG1 "${ANDROID_TOOLCHAIN_ROOT}/bin/${ANDROID_TOOLCHAIN_MACHINE_NAME}-g++${TOOL_OS_SUFFIX}" CACHE PATH "C++ compiler")
+  endif()
  else()
-  set( CMAKE_C_COMPILER   "${ANDROID_TOOLCHAIN_ROOT}/bin/${ANDROID_TOOLCHAIN_MACHINE_NAME}-gcc${TOOL_OS_SUFFIX}"    CACHE PATH "gcc" )
-  set( CMAKE_CXX_COMPILER "${ANDROID_TOOLCHAIN_ROOT}/bin/${ANDROID_TOOLCHAIN_MACHINE_NAME}-g++${TOOL_OS_SUFFIX}"    CACHE PATH "g++" )
+  if( ANDROID_COMPILER_IS_CLANG )
+   set( CMAKE_C_COMPILER   "${ANDROID_CLANG_TOOLCHAIN_ROOT}/bin/${_clang_name}${TOOL_OS_SUFFIX}"   CACHE PATH "C compiler")
+   set( CMAKE_CXX_COMPILER "${ANDROID_CLANG_TOOLCHAIN_ROOT}/bin/${_clang_name}++${TOOL_OS_SUFFIX}" CACHE PATH "C++ compiler")
+  else()
+   set( CMAKE_C_COMPILER   "${ANDROID_TOOLCHAIN_ROOT}/bin/${ANDROID_TOOLCHAIN_MACHINE_NAME}-gcc${TOOL_OS_SUFFIX}"    CACHE PATH "C compiler" )
+   set( CMAKE_CXX_COMPILER "${ANDROID_TOOLCHAIN_ROOT}/bin/${ANDROID_TOOLCHAIN_MACHINE_NAME}-g++${TOOL_OS_SUFFIX}"    CACHE PATH "C++ compiler" )
+  endif()
  endif()
  set( CMAKE_ASM_COMPILER "${ANDROID_TOOLCHAIN_ROOT}/bin/${ANDROID_TOOLCHAIN_MACHINE_NAME}-gcc${TOOL_OS_SUFFIX}"     CACHE PATH "assembler" )
  set( CMAKE_STRIP        "${ANDROID_TOOLCHAIN_ROOT}/bin/${ANDROID_TOOLCHAIN_MACHINE_NAME}-strip${TOOL_OS_SUFFIX}"   CACHE PATH "strip" )
@@ -982,15 +1084,22 @@ endif()
 # Force set compilers because standard identification works badly for us
 include( CMakeForceCompiler )
 CMAKE_FORCE_C_COMPILER( "${CMAKE_C_COMPILER}" GNU )
+if( ANDROID_COMPILER_IS_CLANG )
+ set( CMAKE_C_COMPILER_ID Clang)
+endif()
 set( CMAKE_C_PLATFORM_ID Linux )
 set( CMAKE_C_SIZEOF_DATA_PTR 4 )
 set( CMAKE_C_HAS_ISYSROOT 1 )
 set( CMAKE_C_COMPILER_ABI ELF )
 CMAKE_FORCE_CXX_COMPILER( "${CMAKE_CXX_COMPILER}" GNU )
+if( ANDROID_COMPILER_IS_CLANG )
+ set( CMAKE_CXX_COMPILER_ID Clang)
+endif()
 set( CMAKE_CXX_PLATFORM_ID Linux )
 set( CMAKE_CXX_SIZEOF_DATA_PTR 4 )
 set( CMAKE_CXX_HAS_ISYSROOT 1 )
 set( CMAKE_CXX_COMPILER_ABI ELF )
+set( CMAKE_CXX_SOURCE_FILE_EXTENSIONS cc cp cxx cpp CPP c++ C )
 # force ASM compiler (required for CMake < 2.8.5)
 set( CMAKE_ASM_COMPILER_ID_RUN TRUE )
 set( CMAKE_ASM_COMPILER_ID GNU )
@@ -1056,10 +1165,10 @@ if( ARMEABI_V7A )
  elseif( VFPV3 )
   set( ANDROID_CXX_FLAGS "${ANDROID_CXX_FLAGS} -mfpu=vfpv3" )
  else()
-  set( ANDROID_CXX_FLAGS "${ANDROID_CXX_FLAGS} -mfpu=vfp" )
+  set( ANDROID_CXX_FLAGS "${ANDROID_CXX_FLAGS} -mfpu=vfpv3-d16" )
  endif()
 elseif( ARMEABI_V6 )
- set( ANDROID_CXX_FLAGS "${ANDROID_CXX_FLAGS} -march=armv6 -mfloat-abi=softfp -mfpu=vfp" )
+ set( ANDROID_CXX_FLAGS "${ANDROID_CXX_FLAGS} -march=armv6 -mfloat-abi=softfp -mfpu=vfp" ) # vfp == vfpv2
 elseif( ARMEABI )
  set( ANDROID_CXX_FLAGS "${ANDROID_CXX_FLAGS} -march=armv5te -mtune=xscale -msoft-float" )
 endif()
@@ -1148,17 +1257,25 @@ if( ANDROID_FUNCTION_LEVEL_LINKING )
  set( ANDROID_LINKER_FLAGS "${ANDROID_LINKER_FLAGS} -Wl,--gc-sections" )
 endif()
 
-if( ANDROID_GOLD_LINKER AND CMAKE_HOST_UNIX AND (ARMEABI OR ARMEABI_V7A OR X86) AND ANDROID_COMPILER_VERSION VERSION_EQUAL "4.6" )
- set( ANDROID_LINKER_FLAGS "${ANDROID_LINKER_FLAGS} -fuse-ld=gold" )
-elseif( ANDROID_NDK_RELEASE STREQUAL "r8b" AND ARMEABI AND ANDROID_COMPILER_VERSION VERSION_EQUAL "4.6" AND NOT _CMAKE_IN_TRY_COMPILE )
- message( WARNING "The default bfd linker from arm GCC 4.6 toolchain can fail with 'unresolvable R_ARM_THM_CALL relocation' error message. See https://code.google.com/p/android/issues/detail?id=35342
+if( ANDROID_COMPILER_VERSION VERSION_EQUAL "4.6" )
+ if( ANDROID_GOLD_LINKER AND (CMAKE_HOST_UNIX OR ANDROID_NDK_RELEASE STRGREATER "r8b") AND (ARMEABI OR ARMEABI_V7A OR X86) )
+  set( ANDROID_LINKER_FLAGS "${ANDROID_LINKER_FLAGS} -fuse-ld=gold" )
+ elseif( ANDROID_NDK_RELEASE STREQUAL "r8c")
+  set( ANDROID_LINKER_FLAGS "${ANDROID_LINKER_FLAGS} -fuse-ld=bfd" )
+ elseif( ANDROID_NDK_RELEASE STREQUAL "r8b" AND ARMEABI AND NOT _CMAKE_IN_TRY_COMPILE )
+  message( WARNING "The default bfd linker from arm GCC 4.6 toolchain can fail with 'unresolvable R_ARM_THM_CALL relocation' error message. See https://code.google.com/p/android/issues/detail?id=35342
   On Linux and OS X host platform you can workaround this problem using gold linker (default).
-  Rerun cmake with -DANDROID_GOLD_LINKER=ON option.
+  Rerun cmake with -DANDROID_GOLD_LINKER=ON option in case of problems.
 " )
-endif()
+ endif()
+endif() # version 4.6
 
 if( ANDROID_NOEXECSTACK )
- set( ANDROID_CXX_FLAGS    "${ANDROID_CXX_FLAGS} -Wa,--noexecstack" )
+ if( ANDROID_COMPILER_IS_CLANG )
+  set( ANDROID_CXX_FLAGS    "${ANDROID_CXX_FLAGS} -Xclang -mnoexecstack" )
+ else()
+  set( ANDROID_CXX_FLAGS    "${ANDROID_CXX_FLAGS} -Wa,--noexecstack" )
+ endif()
  set( ANDROID_LINKER_FLAGS "${ANDROID_LINKER_FLAGS} -Wl,-z,noexecstack" )
 endif()
 
@@ -1166,6 +1283,22 @@ if( ANDROID_RELRO )
  set( ANDROID_LINKER_FLAGS "${ANDROID_LINKER_FLAGS} -Wl,-z,relro -Wl,-z,now" )
 endif()
 
+if( ANDROID_COMPILER_IS_CLANG )
+ set( ANDROID_CXX_FLAGS "-Qunused-arguments ${ANDROID_CXX_FLAGS}" )
+ if( ARMEABI_V7A AND NOT ANDROID_FORCE_ARM_BUILD )
+  set( ANDROID_CXX_FLAGS_RELEASE "-target thumbv7-none-linux-androideabi ${ANDROID_CXX_FLAGS_RELEASE}" )
+  set( ANDROID_CXX_FLAGS_DEBUG   "-target ${ANDROID_LLVM_TRIPLE} ${ANDROID_CXX_FLAGS_DEBUG}" )
+ else()
+  set( ANDROID_CXX_FLAGS "-target ${ANDROID_LLVM_TRIPLE} ${ANDROID_CXX_FLAGS}" )
+ endif()
+ if( BUILD_WITH_ANDROID_NDK )
+  if(ANDROID_ARCH_NAME STREQUAL "arm" )
+   set( ANDROID_CXX_FLAGS "-isystem ${ANDROID_CLANG_TOOLCHAIN_ROOT}/lib/clang/${ANDROID_CLANG_VERSION}/include ${ANDROID_CXX_FLAGS}" )
+  endif()
+  set( ANDROID_CXX_FLAGS "-gcc-toolchain ${ANDROID_TOOLCHAIN_ROOT} ${ANDROID_CXX_FLAGS}" )
+ endif()
+endif()
+
 # cache flags
 set( CMAKE_CXX_FLAGS           ""                        CACHE STRING "c++ flags" )
 set( CMAKE_C_FLAGS             ""                        CACHE STRING "c flags" )
@@ -1189,9 +1322,9 @@ set( CMAKE_MODULE_LINKER_FLAGS "${ANDROID_LINKER_FLAGS} ${CMAKE_MODULE_LINKER_FL
 set( CMAKE_EXE_LINKER_FLAGS    "${ANDROID_LINKER_FLAGS} ${CMAKE_EXE_LINKER_FLAGS}" )
 
 if( MIPS AND BUILD_WITH_ANDROID_NDK AND ANDROID_NDK_RELEASE STREQUAL "r8" )
- set( CMAKE_SHARED_LINKER_FLAGS "-Wl,-T,${ANDROID_NDK}/toolchains/${ANDROID_TOOLCHAIN_NAME}/mipself.xsc ${CMAKE_SHARED_LINKER_FLAGS}" )
- set( CMAKE_MODULE_LINKER_FLAGS "-Wl,-T,${ANDROID_NDK}/toolchains/${ANDROID_TOOLCHAIN_NAME}/mipself.xsc ${CMAKE_MODULE_LINKER_FLAGS}" )
- set( CMAKE_EXE_LINKER_FLAGS    "-Wl,-T,${ANDROID_NDK}/toolchains/${ANDROID_TOOLCHAIN_NAME}/mipself.x ${CMAKE_EXE_LINKER_FLAGS}" )
+ set( CMAKE_SHARED_LINKER_FLAGS "-Wl,-T,${ANDROID_NDK}/toolchains/${ANDROID_GCC_TOOLCHAIN_NAME}/mipself.xsc ${CMAKE_SHARED_LINKER_FLAGS}" )
+ set( CMAKE_MODULE_LINKER_FLAGS "-Wl,-T,${ANDROID_NDK}/toolchains/${ANDROID_GCC_TOOLCHAIN_NAME}/mipself.xsc ${CMAKE_MODULE_LINKER_FLAGS}" )
+ set( CMAKE_EXE_LINKER_FLAGS    "-Wl,-T,${ANDROID_NDK}/toolchains/${ANDROID_GCC_TOOLCHAIN_NAME}/mipself.x ${CMAKE_EXE_LINKER_FLAGS}" )
 endif()
 
 # configure rtti
@@ -1218,6 +1351,19 @@ endif()
 include_directories( SYSTEM "${ANDROID_SYSROOT}/usr/include" ${ANDROID_STL_INCLUDE_DIRS} )
 link_directories( "${CMAKE_INSTALL_PREFIX}/libs/${ANDROID_NDK_ABI_NAME}" )
 
+# setup output directories
+set( LIBRARY_OUTPUT_PATH_ROOT ${CMAKE_SOURCE_DIR} CACHE PATH "root for library output, set this to change where android libs are installed to" )
+set( CMAKE_INSTALL_PREFIX "${ANDROID_TOOLCHAIN_ROOT}/user" CACHE STRING "path for installing" )
+
+if(NOT _CMAKE_IN_TRY_COMPILE)
+ if( EXISTS "${CMAKE_SOURCE_DIR}/jni/CMakeLists.txt" )
+  set( EXECUTABLE_OUTPUT_PATH "${LIBRARY_OUTPUT_PATH_ROOT}/bin/${ANDROID_NDK_ABI_NAME}" CACHE PATH "Output directory for applications" )
+ else()
+  set( EXECUTABLE_OUTPUT_PATH "${LIBRARY_OUTPUT_PATH_ROOT}/bin" CACHE PATH "Output directory for applications" )
+ endif()
+ set( LIBRARY_OUTPUT_PATH "${LIBRARY_OUTPUT_PATH_ROOT}/libs/${ANDROID_NDK_ABI_NAME}" CACHE PATH "path for android libs" )
+endif()
+
 # set these global flags for cmake client scripts to change behavior
 set( ANDROID True )
 set( BUILD_ANDROID True )
@@ -1335,7 +1481,7 @@ endif()
 # Variables controlling behavior or set by cmake toolchain:
 #   ANDROID_ABI : "armeabi-v7a" (default), "armeabi", "armeabi-v7a with NEON", "armeabi-v7a with VFPV3", "armeabi-v6 with VFP", "x86", "mips"
 #   ANDROID_NATIVE_API_LEVEL : 3,4,5,8,9,14 (depends on NDK version)
-#   ANDROID_SET_OBSOLETE_VARIABLES : ON/OFF
+#   ANDROID_STL : gnustl_static/gnustl_shared/stlport_static/stlport_shared/gabi++_static/gabi++_shared/system_re/system/none
 #   ANDROID_FORBID_SYGWIN : ON/OFF
 #   ANDROID_NO_UNDEFINED : ON/OFF
 #   ANDROID_SO_UNDEFINED : OFF/ON  (default depends on NDK version)
@@ -1343,16 +1489,15 @@ endif()
 #   ANDROID_GOLD_LINKER : ON/OFF
 #   ANDROID_NOEXECSTACK : ON/OFF
 #   ANDROID_RELRO : ON/OFF
-# Variables that takes effect only at first run:
 #   ANDROID_FORCE_ARM_BUILD : ON/OFF
-#   ANDROID_STL : gnustl_static/gnustl_shared/stlport_static/stlport_shared/gabi++_static/gabi++_shared/system_re/system/none
 #   ANDROID_STL_FORCE_FEATURES : ON/OFF
-#   LIBRARY_OUTPUT_PATH_ROOT : <any valid path>
-#   NDK_CCACHE : <path to your ccache executable>
+#   ANDROID_SET_OBSOLETE_VARIABLES : ON/OFF
 # Can be set only at the first run:
 #   ANDROID_NDK
 #   ANDROID_STANDALONE_TOOLCHAIN
-#   ANDROID_TOOLCHAIN_NAME : "arm-linux-androideabi-4.4.3" or "arm-linux-androideabi-4.6" or "mipsel-linux-android-4.4.3" or "mipsel-linux-android-4.6" or "x86-4.4.3" or "x86-4.6"
+#   ANDROID_TOOLCHAIN_NAME : the NDK name of compiler toolchain
+#   LIBRARY_OUTPUT_PATH_ROOT : <any valid path>
+#   NDK_CCACHE : <path to your ccache executable>
 # Obsolete:
 #   ANDROID_API_LEVEL : superseded by ANDROID_NATIVE_API_LEVEL
 #   ARM_TARGET : superseded by ANDROID_ABI
@@ -1375,10 +1520,11 @@ endif()
 #   BUILD_WITH_STANDALONE_TOOLCHAIN : TRUE if standalone toolchain is used
 #   ANDROID_NDK_HOST_SYSTEM_NAME : "windows", "linux-x86" or "darwin-x86" depending on host platform
 #   ANDROID_NDK_ABI_NAME : "armeabi", "armeabi-v7a", "x86" or "mips" depending on ANDROID_ABI
-#   ANDROID_NDK_RELEASE : one of r5, r5b, r5c, r6, r6b, r7, r7b, r7c, r8, r8b; set only for NDK
+#   ANDROID_NDK_RELEASE : one of r5, r5b, r5c, r6, r6b, r7, r7b, r7c, r8, r8b, r8c; set only for NDK
 #   ANDROID_ARCH_NAME : "arm" or "x86" or "mips" depending on ANDROID_ABI
 #   ANDROID_SYSROOT : path to the compiler sysroot
 #   TOOL_OS_SUFFIX : "" or ".exe" depending on host platform
+#   ANDROID_COMPILER_IS_CLANG : TRUE if clang compiler is used
 # Obsolete:
 #   ARMEABI_NDK_NAME : superseded by ANDROID_NDK_ABI_NAME
 #
@@ -1388,10 +1534,13 @@ endif()
 #   ANDROID_SUPPORTED_ABIS : list of currently allowed values for ANDROID_ABI
 #   ANDROID_TOOLCHAIN_MACHINE_NAME : "arm-linux-androideabi", "arm-eabi" or "i686-android-linux"
 #   ANDROID_TOOLCHAIN_ROOT : path to the top level of toolchain (standalone or placed inside NDK)
+#   ANDROID_CLANG_TOOLCHAIN_ROOT : path to clang tools
 #   ANDROID_SUPPORTED_NATIVE_API_LEVELS : list of native API levels found inside NDK
 #   ANDROID_STL_INCLUDE_DIRS : stl include paths
 #   ANDROID_RTTI : if rtti is enabled by the runtime
 #   ANDROID_EXCEPTIONS : if exceptions are enabled by the runtime
+#   ANDROID_GCC_TOOLCHAIN_NAME : read-only, differs from ANDROID_TOOLCHAIN_NAME only if clang is used
+#   ANDROID_CLANG_VERSION : version of clang compiler if clang is used
 #
 # Defaults:
 #   ANDROID_DEFAULT_NDK_API_LEVEL

android/libinfo/CMakeLists.txt

@@ -0,0 +1,39 @@
+project(libopencv_info)
+if(NOT ANDROID_PACKAGE_RELEASE)
+  set(ANDROID_PACKAGE_RELEASE 1)
+endif()
+
+if(NOT ANDROID_PACKAGE_PLATFORM)
+  if(ARMEABI_V7A)
+    if(NEON)
+      set(ANDROID_PACKAGE_PLATFORM armv7a_neon)
+    else()
+      set(ANDROID_PACKAGE_PLATFORM armv7a)
+    endif()
+  elseif(ARMEABI_V6)
+    set(ANDROID_PACKAGE_PLATFORM armv6)
+  elseif(ARMEABI)
+    set(ANDROID_PACKAGE_PLATFORM armv5)
+  elseif(X86)
+    set(ANDROID_PACKAGE_PLATFORM x86)
+  elseif(MIPS)
+    set(ANDROID_PACKAGE_PLATFORM mips)
+  else()
+    message(ERROR "Can not automatically determine the value for ANDROID_PACKAGE_PLATFORM")
+  endif()
+endif()
+
+add_definitions(-DANDROID_PACKAGE_RELEASE=${ANDROID_PACKAGE_RELEASE} -DANDROID_PACKAGE_PLATFORM="${ANDROID_PACKAGE_PLATFORM}")
+
+include_directories(jni/BinderComponent jni/include "${OpenCV_SOURCE_DIR}/modules/core/include")
+
+add_library(opencv_info SHARED info.c)
+
+set_target_properties(${the_module} PROPERTIES
+    ARCHIVE_OUTPUT_DIRECTORY ${LIBRARY_OUTPUT_PATH}
+    RUNTIME_OUTPUT_DIRECTORY ${EXECUTABLE_OUTPUT_PATH}
+    INSTALL_NAME_DIR lib
+  )
+
+get_filename_component(lib_name "libopencv_info.so" NAME)
+install(FILES "${LIBRARY_OUTPUT_PATH}/${lib_name}" DESTINATION ${OPENCV_LIB_INSTALL_PATH} COMPONENT main)

android/libinfo/info.c

@@ -0,0 +1,31 @@
+#include "opencv2/core/version.hpp"
+#include <jni.h>
+
+const char* GetPackageName(void);
+const char* GetRevision(void);
+const char* GetLibraryList(void);
+JNIEXPORT jstring JNICALL Java_org_opencv_android_StaticHelper_getLibraryList(JNIEnv *, jclass);
+
+#define PACKAGE_NAME "org.opencv.lib_v" CVAUX_STR(CV_MAJOR_VERSION) CVAUX_STR(CV_MINOR_VERSION) "_" ANDROID_PACKAGE_PLATFORM
+#define PACKAGE_REVISION CVAUX_STR(CV_SUBMINOR_VERSION) "." CVAUX_STR(ANDROID_PACKAGE_RELEASE)
+
+const char* GetPackageName(void)
+{
+    return PACKAGE_NAME;
+}
+
+const char* GetRevision(void)
+{
+    return PACKAGE_REVISION;
+}
+
+const char* GetLibraryList(void)
+{
+    return "";
+}
+
+JNIEXPORT jstring JNICALL Java_org_opencv_android_StaticHelper_getLibraryList(JNIEnv * env, jclass clazz)
+{
+    (void)clazz;
+    return (*env)->NewStringUTF(env, GetLibraryList());
+}

android/scripts/camera_build.conf

@@ -16,3 +16,8 @@ native_camera_r4.0.0; armeabi-v7a; 14; /home/alexander/Projects/AndroidSource/4.
 native_camera_r4.1.1; armeabi;     14; /home/alexander/Projects/AndroidSource/4.1.1
 native_camera_r4.1.1; armeabi-v7a; 14; /home/alexander/Projects/AndroidSource/4.1.1
 native_camera_r4.1.1; x86;         14; /home/alexander/Projects/AndroidSource/4.1.1
+native_camera_r4.1.1; mips;        14; /home/alexander/Projects/AndroidSource/4.1.1_mips
+native_camera_r4.2.0; armeabi-v7a; 14; /home/alexander/Projects/AndroidSource/4.2
+native_camera_r4.2.0; armeabi;     14; /home/alexander/Projects/AndroidSource/4.2
+native_camera_r4.2.0; x86;         14; /home/alexander/Projects/AndroidSource/4.2
+native_camera_r4.2.0; mips;        14; /home/alexander/Projects/AndroidSource/4.2

android/scripts/cmake_android_all_cameras.py

@@ -10,11 +10,11 @@ HomeDir = os.getcwd()
 for s in ConfFile.readlines():
     s = s[0:s.find("#")]
     if (not s):
-    continue
+        continue
     keys = s.split(";")
     if (len(keys) < 4):
-    print("Error: invalid config line: \"%s\"" % s)
-    continue
+        print("Error: invalid config line: \"%s\"" % s)
+        continue
     MakeTarget = str.strip(keys[0])
     Arch = str.strip(keys[1])
     NativeApiLevel = str.strip(keys[2])
@@ -22,23 +22,34 @@ for s in ConfFile.readlines():
     AndroidTreeRoot = str.strip(AndroidTreeRoot, "\n")
     print("Building %s for %s" % (MakeTarget, Arch))
     BuildDir = os.path.join(HomeDir, MakeTarget + "_" + Arch)
+
     if (os.path.exists(BuildDir)):
-    shutil.rmtree(BuildDir)
+        shutil.rmtree(BuildDir)
+
     try:
-    os.mkdir(BuildDir)
+        os.mkdir(BuildDir)
     except:
-    print("Error: cannot create direcotry \"%s\"" % BuildDir)
-    continue
+        print("Error: cannot create direcotry \"%s\"" % BuildDir)
+        continue
+
     shutil.rmtree(os.path.join(AndroidTreeRoot, "out", "target", "product", "generic", "system"), ignore_errors=True)
+
+    LinkerLibs = os.path.join(AndroidTreeRoot, "bin_arm", "system")
     if (Arch == "x86"):
-    shutil.copytree(os.path.join(AndroidTreeRoot, "bin_x86", "system"), os.path.join(AndroidTreeRoot, "out", "target", "product", "generic", "system"))
+        LinkerLibs = os.path.join(AndroidTreeRoot, "bin_x86", "system")
     elif (Arch == "mips"):
-    shutil.copytree(os.path.join(AndroidTreeRoot, "bin_mips", "system"), os.path.join(AndroidTreeRoot, "out", "target", "product", "generic", "system"))
-    else:
-    shutil.copytree(os.path.join(AndroidTreeRoot, "bin_arm", "system"), os.path.join(AndroidTreeRoot, "out", "target", "product", "generic", "system"))
+        LinkerLibs = os.path.join(AndroidTreeRoot, "bin_mips", "system")
+
+    if (not os.path.exists(LinkerLibs)):
+        print("Error: Paltform libs for linker in path \"%s\" not found" % LinkerLibs)
+        print("Building %s for %s\t[\033[91mFAILED\033[0m]" % (MakeTarget, Arch))
+        continue
+
+    shutil.copytree(LinkerLibs, os.path.join(AndroidTreeRoot, "out", "target", "product", "generic", "system"))
+
     os.chdir(BuildDir)
     BuildLog = os.path.join(BuildDir, "build.log")
-    CmakeCmdLine = "cmake -DCMAKE_TOOLCHAIN_FILE=../android.toolchain.cmake -DANDROID_SOURCE_TREE=\"%s\" -DANDROID_NATIVE_API_LEVEL=\"%s\" -DANDROID_ABI=\"%s\" -DANDROID_USE_STLPORT=ON ../../ > \"%s\" 2>&1" % (AndroidTreeRoot, NativeApiLevel, Arch, BuildLog)
+    CmakeCmdLine = "cmake -DCMAKE_TOOLCHAIN_FILE=../android.toolchain.cmake -DANDROID_SOURCE_TREE=\"%s\" -DANDROID_NATIVE_API_LEVEL=\"%s\" -DANDROID_ABI=\"%s\" -DANDROID_STL=stlport_static ../../ > \"%s\" 2>&1" % (AndroidTreeRoot, NativeApiLevel, Arch, BuildLog)
     MakeCmdLine = "make %s >> \"%s\" 2>&1" % (MakeTarget, BuildLog);
     #print(CmakeCmdLine)
     os.system(CmakeCmdLine)
@@ -47,12 +58,12 @@ for s in ConfFile.readlines():
     os.chdir(HomeDir)
     CameraLib = os.path.join(BuildDir, "lib", Arch, "lib" + MakeTarget + ".so")
     if (os.path.exists(CameraLib)):
-    try:
-        shutil.copyfile(CameraLib, os.path.join("..", "3rdparty", "lib", Arch, "lib" + MakeTarget + ".so"))
-        print("Building %s for %s\t[\033[92mOK\033[0m]" % (MakeTarget, Arch));
-    except:
-        print("Building %s for %s\t[\033[91mFAILED\033[0m]" % (MakeTarget, Arch));
+        try:
+            shutil.copyfile(CameraLib, os.path.join("..", "3rdparty", "lib", Arch, "lib" + MakeTarget + ".so"))
+            print("Building %s for %s\t[\033[92mOK\033[0m]" % (MakeTarget, Arch));
+        except:
+            print("Building %s for %s\t[\033[91mFAILED\033[0m]" % (MakeTarget, Arch));
     else:
-    print("Building %s for %s\t[\033[91mFAILED\033[0m]" % (MakeTarget, Arch));
-ConfFile.close()
+        print("Building %s for %s\t[\033[91mFAILED\033[0m]" % (MakeTarget, Arch));
 
+ConfFile.close()

android/scripts/cmake_android_service.sh

@@ -4,5 +4,5 @@ cd `dirname $0`/..
 mkdir -p build_service
 cd build_service
 
-cmake -DCMAKE_TOOLCHAIN_FILE=../android.toolchain.cmake -DANDROID_USE_STLPORT=ON -DBUILD_ANDROID_SERVICE=ON -DANDROID_SOURCE_TREE=~/Projects/AndroidSource/2.2.2/ $@ ../..
+cmake -DCMAKE_TOOLCHAIN_FILE=../android.toolchain.cmake -DANDROID_TOOLCHAIN_NAME="arm-linux-androideabi-4.4.3" -DANDROID_STL=stlport_static -DANDROID_STL_FORCE_FEATURES=OFF -DBUILD_ANDROID_SERVICE=ON -DANDROID_SOURCE_TREE=~/Projects/AndroidSource/ServiceStub/ $@ ../..
 

android/service/doc/build_uml.py

@@ -20,4 +20,4 @@ if (not os.path.exists(TARGET_PATH)):
 
 for filename in os.listdir("."):
     if ("dia" == filename[-3:]):
-    os.system("%s --export %s %s" % (DiaPath, os.path.join(TARGET_PATH, filename[0:len(filename)-4] + ".png"), filename))
+        os.system("%s --export %s %s" % (DiaPath, os.path.join(TARGET_PATH, filename[0:len(filename)-4] + ".png"), filename))

android/service/engine/AndroidManifest.xml

@@ -1,10 +1,10 @@
 <?xml version="1.0" encoding="utf-8"?>
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
     package="org.opencv.engine"
-    android:versionCode="18"
-    android:versionName="1.8" >
+    android:versionCode="23@ANDROID_PLATFORM_VERSION_CODE@"
+    android:versionName="2.3" >
 
-    <uses-sdk android:minSdkVersion="8" />
+    <uses-sdk android:minSdkVersion="@ANDROID_NATIVE_API_LEVEL@" />
     <uses-feature android:name="android.hardware.touchscreen" android:required="false"/>
 
     <application

android/service/engine/CMakeLists.txt

@@ -1,10 +1,38 @@
 set(engine OpenCVEngine)
 set(JNI_LIB_NAME ${engine} ${engine}_jni)
-add_android_project(opencv_engine "${CMAKE_CURRENT_SOURCE_DIR}" SDK_TARGET 8 ${ANDROID_SDK_TARGET} IGNORE_JAVA ON)
 
-link_directories("${ANDROID_SOURCE_TREE}/out/target/product/generic/system/lib" "${ANDROID_SOURCE_TREE}/out/target/product/${ANDROID_PRODUCT}/system/lib" "${ANDROID_SOURCE_TREE}/bin_${ANDROID_ARCH_NAME}/system/lib")
+unset(__android_project_chain CACHE)
+add_android_project(opencv_engine "${CMAKE_CURRENT_SOURCE_DIR}" SDK_TARGET 8 ${ANDROID_SDK_TARGET} IGNORE_JAVA ON IGNORE_MANIFEST ON )
 
-SET(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,-allow-shlib-undefined")
+set(ANDROID_PLATFORM_VERSION_CODE "0")
+
+if(ARMEABI_V7A)
+  if (ANDROID_NATIVE_API_LEVEL LESS 9)
+    set(ANDROID_PLATFORM_VERSION_CODE "2")
+  else()
+    set(ANDROID_PLATFORM_VERSION_CODE "3")
+  endif()
+elseif(ARMEABI_V6)
+  set(ANDROID_PLATFORM_VERSION_CODE "1")
+elseif(ARMEABI)
+  set(ANDROID_PLATFORM_VERSION_CODE "1")
+elseif(X86)
+  set(ANDROID_PLATFORM_VERSION_CODE "4")
+elseif(MIPS)
+  set(ANDROID_PLATFORM_VERSION_CODE "5")
+else()
+  message(WARNING "Can not automatically determine the value for ANDROID_PLATFORM_VERSION_CODE")
+endif()
+
+configure_file("${CMAKE_CURRENT_SOURCE_DIR}/${ANDROID_MANIFEST_FILE}" "${OpenCV_BINARY_DIR}/android/service/engine/.build/${ANDROID_MANIFEST_FILE}"  @ONLY)
+
+link_directories("${ANDROID_SOURCE_TREE}/out/target/product/generic/system/lib" "${ANDROID_SOURCE_TREE}/out/target/product/${ANDROID_PRODUCT}/system/lib" "${ANDROID_SOURCE_TREE}/bin/${ANDROID_ARCH_NAME}")
+
+# -D__SUPPORT_ARMEABI_FEATURES key is also available
+add_definitions(-DPLATFORM_ANDROID -D__SUPPORT_ARMEABI_V7A_FEATURES -D__SUPPORT_TEGRA3 -D__SUPPORT_MIPS)
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-rtti -fno-exceptions")
+
+set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,-allow-shlib-undefined")
 file(GLOB engine_files "jni/BinderComponent/*.cpp" "jni/BinderComponent/*.h" "jni/include/*.h")
 
 include_directories(jni/BinderComponent jni/include)

android/service/engine/jni/Android.mk

@@ -35,7 +35,7 @@ LOCAL_MODULE := libOpenCVEngine
 
 LOCAL_LDLIBS += -lz -lbinder -llog -lutils
 
-LOCAL_LDFLAGS += -Wl,-allow-shlib-undefine
+LOCAL_LDFLAGS += -Wl,-allow-shlib-undefined
 
 include $(BUILD_SHARED_LIBRARY)
 
@@ -74,7 +74,6 @@ LOCAL_CFLAGS += -D__SUPPORT_MIPS
 LOCAL_MODULE := libOpenCVEngine_jni
 
 LOCAL_LDLIBS += -lz -lbinder -llog -lutils -landroid_runtime
-
 LOCAL_SHARED_LIBRARIES = libOpenCVEngine
 
 include $(BUILD_SHARED_LIBRARY)
@@ -83,4 +82,4 @@ include $(BUILD_SHARED_LIBRARY)
 #        Native test application
 #---------------------------------------------------------------------
 
-include $(LOCAL_PATH)/Tests/Tests.mk
+#include $(LOCAL_PATH)/Tests/Tests.mk

android/service/engine/jni/Application.mk

@@ -2,4 +2,5 @@ APP_ABI := armeabi x86 mips
 APP_PLATFORM := android-8
 APP_STL := stlport_static
 APP_CPPFLAGS := -fno-rtti -fno-exceptions
+NDK_TOOLCHAIN_VERSION=4.4.3
 #APP_OPTIM := debug

android/service/engine/jni/BinderComponent/OpenCVEngine.cpp

@@ -130,7 +130,7 @@ android::String16 OpenCVEngine::GetLibraryList(android::String16 version)
             LOGD("Trying to load info library \"%s\"", tmp.c_str());
 
             void* handle;
-            char* (*info_func)();
+            const char* (*info_func)();
 
             handle = dlopen(tmp.c_str(), RTLD_LAZY);
             if (handle)

android/service/engine/jni/JNIWrapper/HardwareDetector_jni.cpp

@@ -3,7 +3,7 @@
 #include <jni.h>
 #include <string>
 
-JNIEXPORT jint JNICALL Java_org_opencv_engine_HardwareDetector_GetCpuID(JNIEnv* env, jclass)
+JNIEXPORT jint JNICALL Java_org_opencv_engine_HardwareDetector_GetCpuID(JNIEnv* , jclass)
 {
     return GetCpuID();
 }
@@ -14,12 +14,12 @@ JNIEXPORT jstring JNICALL Java_org_opencv_engine_HardwareDetector_GetPlatformNam
     return env->NewStringUTF(hardware_name.c_str());
 }
 
-JNIEXPORT jint JNICALL Java_org_opencv_engine_HardwareDetector_GetProcessorCount(JNIEnv* env, jclass)
+JNIEXPORT jint JNICALL Java_org_opencv_engine_HardwareDetector_GetProcessorCount(JNIEnv* , jclass)
 {
     return GetProcessorCount();
 }
 
-JNIEXPORT jint JNICALL Java_org_opencv_engine_HardwareDetector_DetectKnownPlatforms(JNIEnv* env, jclass)
+JNIEXPORT jint JNICALL Java_org_opencv_engine_HardwareDetector_DetectKnownPlatforms(JNIEnv* , jclass)
 {
     return DetectKnownPlatforms();
 }

android/service/engine/jni/JNIWrapper/OpenCVEngine_jni.cpp

@@ -30,7 +30,7 @@ JNIEXPORT jobject JNICALL Java_org_opencv_engine_BinderConnector_Connect(JNIEnv*
     return javaObjectForIBinder(env, OpenCVEngineBinder);
 }
 
-JNIEXPORT jboolean JNICALL Java_org_opencv_engine_BinderConnector_Init(JNIEnv* env, jobject thiz, jobject market)
+JNIEXPORT jboolean JNICALL Java_org_opencv_engine_BinderConnector_Init(JNIEnv* env, jobject , jobject market)
 {
     LOGD("Java_org_opencv_engine_BinderConnector_Init");
 

android/service/engine/jni/NativeService/PackageInfo.cpp

@@ -363,7 +363,7 @@ InstallPath(install_path)
                 }
                 else
                 {
-                    LOGE("Library loading error (%x, %x): \"%s\"", name_func, revision_func, error);
+                    LOGE("Library loading error (%p, %p): \"%s\"", name_func, revision_func, error);
                 }
             }
             else

android/service/engine/jni/Tests/Tests.mk

@@ -36,7 +36,7 @@ LOCAL_CFLAGS += -D__SUPPORT_TEGRA3
 LOCAL_CFLAGS += -D__SUPPORT_MIPS
 #LOCAL_CFLAGS += -D__SUPPORT_ARMEABI_FEATURES
 
-LOCAL_LDFLAGS = -Wl,-allow-shlib-undefined
+#LOCAL_LDFLAGS = -Wl,-allow-shlib-undefined
 
 LOCAL_MODULE := OpenCVEngineTestApp
 

android/service/engine/jni/include/EngineCommon.h

@@ -5,10 +5,16 @@
 #undef LOG_TAG
 #define LOG_TAG "OpenCVEngine"
 
+// OpenCV Engine API version
 #ifndef OPEN_CV_ENGINE_VERSION
-    #define OPEN_CV_ENGINE_VERSION 1
+    #define OPEN_CV_ENGINE_VERSION 2
 #endif
 
 #define LIB_OPENCV_INFO_NAME "libopencv_info.so"
 
+// OpenCV Manager package name
+#define OPENCV_ENGINE_PACKAGE "org.opencv.engine"
+// Class name of OpenCV engine binder object. Is needned for connection to service
+#define OPECV_ENGINE_CLASSNAME "org.opencv.engine.OpenCVEngineInterface"
+
 #endif

android/service/engine/jni/include/IOpenCVEngine.h

@@ -4,11 +4,7 @@
 #include <binder/IInterface.h>
 #include <binder/Parcel.h>
 #include <utils/String16.h>
-
-// OpenCV Manager package name
-#define OPENCV_ENGINE_PACKAGE "org.opencv.engine"
-// Class name of OpenCV engine binder object. Is needned for connection to service
-#define OPECV_ENGINE_CLASSNAME "org.opencv.engine.OpenCVEngineInterface"
+#include "EngineCommon.h"
 
 enum EngineMethonID
 {

cmake/OpenCVDetectAndroidSDK.cmake

@@ -179,7 +179,7 @@ unset(__android_project_chain CACHE)
 #add_android_project(target_name ${path} NATIVE_DEPS opencv_core LIBRARY_DEPS ${OpenCV_BINARY_DIR} SDK_TARGET 11)
 macro(add_android_project target path)
   # parse arguments
-  set(android_proj_arglist NATIVE_DEPS LIBRARY_DEPS SDK_TARGET IGNORE_JAVA)
+  set(android_proj_arglist NATIVE_DEPS LIBRARY_DEPS SDK_TARGET IGNORE_JAVA IGNORE_MANIFEST)
   set(__varname "android_proj_")
   foreach(v ${android_proj_arglist})
     set(${__varname}${v} "")
@@ -220,9 +220,13 @@ macro(add_android_project target path)
     # get project sources
     file(GLOB_RECURSE android_proj_files RELATIVE "${path}" "${path}/res/*" "${path}/src/*")
 
+    if(NOT android_proj_IGNORE_MANIFEST)
+      list(APPEND android_proj_files ${ANDROID_MANIFEST_FILE})
+    endif()
+
     # copy sources out from the build tree
     set(android_proj_file_deps "")
-    foreach(f ${android_proj_files} ${ANDROID_MANIFEST_FILE})
+    foreach(f ${android_proj_files})
       add_custom_command(
         OUTPUT "${android_proj_bin_dir}/${f}"
         COMMAND ${CMAKE_COMMAND} -E copy "${path}/${f}" "${android_proj_bin_dir}/${f}"
@@ -324,6 +328,7 @@ macro(add_android_project target path)
       install(FILES "${OpenCV_BINARY_DIR}/bin/${target}.apk" DESTINATION "samples" COMPONENT main)
       get_filename_component(sample_dir "${path}" NAME)
       #java part
+      list(REMOVE_ITEM android_proj_files ${ANDROID_MANIFEST_FILE})
       foreach(f ${android_proj_files} ${ANDROID_MANIFEST_FILE})
         get_filename_component(install_subdir "${f}" PATH)
         install(FILES "${android_proj_bin_dir}/${f}" DESTINATION "samples/${sample_dir}/${install_subdir}" COMPONENT main)

cmake/OpenCVDetectCUDA.cmake

@@ -3,8 +3,13 @@ if(${CMAKE_VERSION} VERSION_LESS "2.8.3")
   return()
 endif()
 
-if (NOT MSVC AND NOT CMAKE_COMPILER_IS_GNUCXX OR MINGW)
-  message(STATUS "CUDA compilation was disabled (due to unsuppoted host compiler).")
+if (WIN32 AND NOT MSVC)
+  message(STATUS "CUDA compilation is disabled (due to only Visual Studio compiler suppoted on your platform).")
+  return()
+endif()
+
+if (CMAKE_COMPILER_IS_GNUCXX AND NOT APPLE AND CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
+  message(STATUS "CUDA compilation is disabled (due to Clang unsuppoted on your platform).")
   return()
 endif()
 

cmake/OpenCVDetectCXXCompiler.cmake

@@ -54,7 +54,7 @@ endif()
 # Detect GNU version:
 # ----------------------------------------------------------------------------
 if(CMAKE_COMPILER_IS_GNUCXX)
-    execute_process(COMMAND ${CMAKE_CXX_COMPILER} ${CMAKE_CXX_COMPILER_ARG1} --version
+    execute_process(COMMAND ${CMAKE_CXX_COMPILER} ${CMAKE_CXX_COMPILER_ARG1} -dumpversion
                   OUTPUT_VARIABLE CMAKE_OPENCV_GCC_VERSION_FULL
                   OUTPUT_STRIP_TRAILING_WHITESPACE)
 

cmake/OpenCVGenAndroidMK.cmake

@@ -71,6 +71,12 @@ if(ANDROID)
   endforeach()
   string(REPLACE "opencv_" "" OPENCV_MODULES_CONFIGMAKE "${OPENCV_MODULES_CONFIGMAKE}")
 
+  # prepare 3rd-party component list without TBB for armeabi and mips platforms. TBB is useless there.
+  set(OPENCV_3RDPARTY_COMPONENTS_CONFIGMAKE_NO_TBB ${OPENCV_3RDPARTY_COMPONENTS_CONFIGMAKE})
+  foreach(mod ${OPENCV_3RDPARTY_COMPONENTS_CONFIGMAKE_NO_TBB})
+     string(REPLACE "tbb" "" OPENCV_3RDPARTY_COMPONENTS_CONFIGMAKE_NO_TBB "${OPENCV_3RDPARTY_COMPONENTS_CONFIGMAKE_NO_TBB}")
+  endforeach()
+
   if(BUILD_FAT_JAVA_LIB)
     set(OPENCV_LIBS_CONFIGMAKE java)
   else()

cmake/OpenCVVersion.cmake

@@ -5,7 +5,7 @@ string(REGEX REPLACE ".+CV_MAJOR_VERSION[ ]+([0-9]+).*" "\\1" OPENCV_VERSION_MAJ
 string(REGEX REPLACE ".+CV_MINOR_VERSION[ ]+([0-9]+).*" "\\1" OPENCV_VERSION_MINOR "${OPENCV_VERSION_PARTS}")
 string(REGEX REPLACE ".+CV_SUBMINOR_VERSION[ ]+([0-9]+).*" "\\1" OPENCV_VERSION_PATCH "${OPENCV_VERSION_PARTS}")
 
-set(OPENCV_VERSION "${OPENCV_VERSION_MAJOR}.${OPENCV_VERSION_MINOR}.${OPENCV_VERSION_PATCH}")
+set(OPENCV_VERSION "${OPENCV_VERSION_MAJOR}.${OPENCV_VERSION_MINOR}.${OPENCV_VERSION_PATCH}.1")
 set(OPENCV_SOVERSION "${OPENCV_VERSION_MAJOR}.${OPENCV_VERSION_MINOR}")
 
 # create a dependency on version file

cmake/templates/OpenCV.mk.in

@@ -29,8 +29,22 @@ ifeq ($(OPENCV_LIB_TYPE),SHARED)
     OPENCV_3RDPARTY_COMPONENTS:=
     OPENCV_EXTRA_COMPONENTS:=
 else
-    OPENCV_3RDPARTY_COMPONENTS:=@OPENCV_3RDPARTY_COMPONENTS_CONFIGMAKE@
-    OPENCV_EXTRA_COMPONENTS:=@OPENCV_EXTRA_COMPONENTS_CONFIGMAKE@
+    ifeq ($(TARGET_ARCH_ABI),armeabi-v7a)
+        OPENCV_3RDPARTY_COMPONENTS:=@OPENCV_3RDPARTY_COMPONENTS_CONFIGMAKE@
+        OPENCV_EXTRA_COMPONENTS:=@OPENCV_EXTRA_COMPONENTS_CONFIGMAKE@
+    endif
+    ifeq ($(TARGET_ARCH_ABI),x86)
+        OPENCV_3RDPARTY_COMPONENTS:=@OPENCV_3RDPARTY_COMPONENTS_CONFIGMAKE@
+        OPENCV_EXTRA_COMPONENTS:=@OPENCV_EXTRA_COMPONENTS_CONFIGMAKE@
+    endif
+    ifeq ($(TARGET_ARCH_ABI),armeabi)
+        OPENCV_3RDPARTY_COMPONENTS:=@OPENCV_3RDPARTY_COMPONENTS_CONFIGMAKE_NO_TBB@
+        OPENCV_EXTRA_COMPONENTS:=@OPENCV_EXTRA_COMPONENTS_CONFIGMAKE@
+    endif
+    ifeq ($(TARGET_ARCH_ABI),mips)
+        OPENCV_3RDPARTY_COMPONENTS:=@OPENCV_3RDPARTY_COMPONENTS_CONFIGMAKE_NO_TBB@
+        OPENCV_EXTRA_COMPONENTS:=@OPENCV_EXTRA_COMPONENTS_CONFIGMAKE@
+    endif
 endif
 
 ifeq (${OPENCV_CAMERA_MODULES},on)

doc/check_docs.py

@@ -1,3 +1,5 @@
+#/usr/bin/env python
+
 import sys, glob
 
 sys.path.append("../modules/python/src2/")

doc/check_docs2.py

@@ -1,3 +1,5 @@
+#/usr/bin/env python
+
 import os, sys, fnmatch, re
 
 sys.path.append("../modules/python/src2/")

doc/conf.py

@@ -1,3 +1,5 @@
+#/usr/bin/env python
+
 # -*- coding: utf-8 -*-
 #
 # opencvstd documentation build configuration file, created by
@@ -293,7 +295,7 @@ extlinks = {
             'svms':('http://opencv.itseez.com/modules/ml/doc/support_vector_machines.html#%s', None),
             'drawingfunc':('http://opencv.itseez.com/modules/core/doc/drawing_functions.html#%s', None),
             'xmlymlpers':('http://opencv.itseez.com/modules/core/doc/xml_yaml_persistence.html#%s', None),
-            'huivideo' : ('http://opencv.itseez.com/modules/highgui/doc/reading_and_writing_images_and_video.html#%s', None),
+            'hgvideo' : ('http://opencv.itseez.com/modules/highgui/doc/reading_and_writing_images_and_video.html#%s', None),
             'gpuinit' : ('http://opencv.itseez.com/modules/gpu/doc/initalization_and_information.html#%s', None),
             'gpudatastructure' : ('http://opencv.itseez.com/modules/gpu/doc/data_structures.html#%s', None),
             'gpuopmatrices' : ('http://opencv.itseez.com/modules/gpu/doc/operations_on_matrices.html#%s', None),

doc/ocv.py

@@ -1,3 +1,4 @@
+#/usr/bin/env python
 # -*- coding: utf-8 -*-
 """
     ocv domain, a modified copy of sphinx.domains.cpp + shpinx.domains.python.

doc/patch_refman_latex.py

@@ -1,3 +1,5 @@
+#/usr/bin/env python
+
 import sys
 
 f=open(sys.argv[1], "rt")

doc/pattern_tools/gen_pattern.py

@@ -1,3 +1,5 @@
+#/usr/bin/env python
+
 """gen_pattern.py
 To run:
 -c 10 -r 12 -o out.svg

doc/pattern_tools/svgfig.py

@@ -1,3 +1,5 @@
+#/usr/bin/env python
+
 # svgfig.py copyright (C) 2008 Jim Pivarski <jpivarski@gmail.com>
 #
 # This program is free software; you can redistribute it and/or

doc/reformat.py

@@ -1,3 +1,5 @@
+#/usr/bin/env python
+
 import os, sys, re
 
 finput=open(sys.argv[1], "rt")

doc/tutorials/contrib/retina_model/retina_model.rst

@@ -0,0 +1,414 @@
+.. _Retina_Model:
+
+Discovering the human retina and its use for image processing
+*************************************************************
+
+Goal
+=====
+
+I present here a model of human retina that shows some interesting properties for image preprocessing and enhancement.
+In this tutorial you will learn how to:
+
+.. container:: enumeratevisibleitemswithsquare
+
+   + discover the main two channels outing from your retina
+
+   + see the basics to use the retina model
+
+   + discover some parameters tweaks
+
+
+General overview
+================
+
+The proposed model originates from Jeanny Herault's research at `Gipsa <http://www.gipsa-lab.inpg.fr>`_. It is involved in image processing applications with `Listic <http://www.listic.univ-savoie.fr>`_ (code maintainer) lab. This is not a complete model but it already present interesting properties that can be involved for enhanced image processing experience. The model allows the following human retina properties to be used :
+
+* spectral whitening that has 3 important effects: high spatio-temporal frequency signals canceling (noise), mid-frequencies details enhancement and low frequencies luminance energy reduction. This *all in one* property directly allows visual signals cleaning of classical undesired distortions introduced by image sensors and input luminance range.
+
+* local logarithmic luminance compression allows details to be enhanced even in low light conditions.
+
+* decorrelation of the details information (Parvocellular output channel) and transient information (events, motion made available at the Magnocellular output channel).
+
+The first two points are illustrated below :
+
+In the figure below, the OpenEXR image sample *CrissyField.exr*, a High Dynamic Range image is shown. In order to make it visible on this web-page, the original input image is linearly rescaled to the classical image luminance range [0-255] and is converted to 8bit/channel format. Such strong conversion hides many details because of too strong local contrasts. Furthermore, noise energy is also strong and pollutes visual information.
+
+.. image:: images/retina_TreeHdr_small.jpg
+   :alt: A High dynamic range image linearly rescaled within range [0-255].
+   :align: center
+
+In the following image, as your retina does, local luminance adaptation, spatial noise removal and spectral whitening work together and transmit accurate information on lower range 8bit data channels. On this picture, noise in significantly removed, local details hidden by strong luminance contrasts are enhanced. Output image keeps its naturalness and visual content is enhanced.
+
+.. image:: images/retina_TreeHdr_retina.jpg
+   :alt: A High dynamic range image compressed within range [0-255] using the retina.
+   :align: center
+
+
+*Note :* image sample can be downloaded from the `OpenEXR website <http://www.openexr.com>`_. Regarding this demonstration, before retina processing, input image has been linearly rescaled within 0-255 keeping its channels float format. 5% of its histogram ends has been cut (mostly removes wrong HDR pixels). Check out the sample *opencv/samples/cpp/OpenEXRimages_HighDynamicRange_Retina_toneMapping.cpp* for similar processing. The following demonstration will only consider classical 8bit/channel images.
+
+The retina model output channels
+================================
+
+The retina model presents two outputs that benefit from the above cited behaviors.
+
+* The first one is called the Parvocellular channel. It is mainly active in the foveal retina area (high resolution central vision with color sensitive photo-receptors), its aim is to provide accurate color vision for visual details remaining static on the retina. On the other hand objects moving on the retina projection are blurred.
+
+* The second well known channel is the Magnocellular channel. It is mainly active in the retina peripheral vision and send signals related to change events (motion, transient events, etc.). These outing signals also help visual system to focus/center retina on 'transient'/moving areas for more detailed analysis thus improving visual scene context and object classification.
+
+**NOTE :** regarding the proposed model, contrary to the real retina, we apply these two channels on the entire input images using the same resolution. This allows enhanced visual details and motion information to be extracted on all the considered images... but remember, that these two channels are complementary. For example, if Magnocellular channel gives strong energy in an area, then, the Parvocellular channel is certainly blurred there since there is a transient event.
+
+As an illustration, we apply in the following the retina model on a webcam video stream of a dark visual scene. In this visual scene, captured in an amphitheater of the university, some students are moving while talking to the teacher.
+
+In this video sequence, because of the dark ambiance, signal to noise ratio is low and color artifacts are present on visual features edges because of the low quality image capture tool-chain.
+
+.. image:: images/studentsSample_input.jpg
+   :alt: an input video stream extract sample
+   :align: center
+
+Below is shown the retina foveal vision applied on the entire image. In the used retina configuration, global luminance is preserved and local contrasts are enhanced. Also, signal to noise ratio is improved : since high frequency spatio-temporal noise is reduced, enhanced details are not corrupted by any enhanced noise.
+
+.. image:: images/studentsSample_parvo.jpg
+   :alt: the retina Parvocellular output. Enhanced details, luminance adaptation and noise removal. A processing tool for image analysis.
+   :align: center
+
+Below is the output of the Magnocellular output of the retina model. Its signals are strong where transient events occur. Here, a student is moving at the bottom of the image thus generating high energy. The remaining of the image is static however, it is corrupted by a strong noise. Here, the retina filters out most of the noise thus generating low false motion area 'alarms'. This channel can be used as a transient/moving areas detector : it would provide relevant information for a low cost segmentation tool that would highlight areas in which an event is occurring.
+
+.. image:: images/studentsSample_magno.jpg
+   :alt: the retina Magnocellular output. Enhanced transient signals (motion, etc.). A preprocessing tool for event detection.
+   :align: center
+
+Retina use case
+===============
+
+This model can be used basically for spatio-temporal video effects but also in the aim of :
+
+* performing texture analysis with enhanced signal to noise ratio and enhanced details robust against input images luminance ranges (check out the Parvocellular retina channel output)
+
+* performing motion analysis also taking benefit of the previously cited properties.
+
+For more information, refer to the following papers :
+
+* Benoit A., Caplier A., Durette B., Herault, J., "Using Human Visual System Modeling For Bio-Inspired Low Level Image Processing", Elsevier, Computer Vision and Image Understanding 114 (2010), pp. 758-773. DOI <http://dx.doi.org/10.1016/j.cviu.2010.01.011>
+
+* Please have a look at the reference work of Jeanny Herault that you can read in his book :
+
+Vision: Images, Signals and Neural Networks: Models of Neural Processing in Visual Perception (Progress in Neural Processing),By: Jeanny Herault, ISBN: 9814273686. WAPI (Tower ID): 113266891.
+
+This retina filter code includes the research contributions of phd/research collegues from which code has been redrawn by the author :
+
+* take a look at the *retinacolor.hpp* module to discover Brice Chaix de Lavarene phD color mosaicing/demosaicing and his reference paper: B. Chaix de Lavarene, D. Alleysson, B. Durette, J. Herault (2007). "Efficient demosaicing through recursive filtering", IEEE International Conference on Image Processing ICIP 2007
+
+* take a look at *imagelogpolprojection.hpp* to discover retina spatial log sampling which originates from Barthelemy Durette phd with Jeanny Herault. A Retina / V1 cortex projection is also proposed and originates from Jeanny's discussions. ====> more information in the above cited Jeanny Heraults's book.
+
+Code tutorial
+=============
+
+Please refer to the original tutorial source code in file *opencv_folder/samples/cpp/tutorial_code/contrib/retina_tutorial.cpp*.
+
+To compile it, assuming OpenCV is correctly installed, use the following command. It requires the opencv_core *(cv::Mat and friends objects management)*, opencv_highgui *(display and image/video read)* and opencv_contrib *(Retina description)* libraries to compile.
+
+.. code-block:: cpp
+
+   // compile
+   gcc retina_tutorial.cpp -o Retina_tuto -lopencv_core -lopencv_highgui -lopencv_contrib
+
+   // Run commands : add 'log' as a last parameter to apply a spatial log sampling (simulates retina sampling)
+   // run on webcam
+   ./Retina_tuto -video
+   // run on video file
+   ./Retina_tuto -video myVideo.avi
+   // run on an image
+   ./Retina_tuto -image myPicture.jpg
+   // run on an image with log sampling
+   ./Retina_tuto -image myPicture.jpg log
+
+Here is a code explanation :
+
+Retina definition is present in the contrib package and a simple include allows to use it
+
+.. code-block:: cpp
+
+   #include "opencv2/opencv.hpp"
+
+Provide user some hints to run the program with a help function
+
+.. code-block:: cpp
+
+   // the help procedure
+   static void help(std::string errorMessage)
+   {
+    std::cout<<"Program init error : "<<errorMessage<<std::endl;
+    std::cout<<"\nProgram call procedure : retinaDemo [processing mode] [Optional : media target] [Optional LAST parameter: \"log\" to activate retina log sampling]"<<std::endl;
+    std::cout<<"\t[processing mode] :"<<std::endl;
+    std::cout<<"\t -image : for still image processing"<<std::endl;
+    std::cout<<"\t -video : for video stream processing"<<std::endl;
+    std::cout<<"\t[Optional : media target] :"<<std::endl;
+    std::cout<<"\t if processing an image or video file, then, specify the path and filename of the target to process"<<std::endl;
+    std::cout<<"\t leave empty if processing video stream coming from a connected video device"<<std::endl;
+    std::cout<<"\t[Optional : activate retina log sampling] : an optional last parameter can be specified for retina spatial log sampling"<<std::endl;
+    std::cout<<"\t set \"log\" without quotes to activate this sampling, output frame size will be divided by 4"<<std::endl;
+    std::cout<<"\nExamples:"<<std::endl;
+    std::cout<<"\t-Image processing : ./retinaDemo -image lena.jpg"<<std::endl;
+    std::cout<<"\t-Image processing with log sampling : ./retinaDemo -image lena.jpg log"<<std::endl;
+    std::cout<<"\t-Video processing : ./retinaDemo -video myMovie.mp4"<<std::endl;
+    std::cout<<"\t-Live video processing : ./retinaDemo -video"<<std::endl;
+    std::cout<<"\nPlease start again with new parameters"<<std::endl;
+    std::cout<<"****************************************************"<<std::endl;
+    std::cout<<" NOTE : this program generates the default retina parameters file 'RetinaDefaultParameters.xml'"<<std::endl;
+    std::cout<<" => you can use this to fine tune parameters and load them if you save to file 'RetinaSpecificParameters.xml'"<<std::endl;
+   }
+
+Then, start the main program and first declare a *cv::Mat* matrix in which input images will be loaded. Also allocate a *cv::VideoCapture* object ready to load video streams (if necessary)
+
+.. code-block:: cpp
+
+  int main(int argc, char* argv[]) {
+    // declare the retina input buffer... that will be fed differently in regard of the input media
+    cv::Mat inputFrame;
+    cv::VideoCapture videoCapture; // in case a video media is used, its manager is declared here
+
+
+In the main program, before processing, first check input command parameters. Here it loads a first input image coming from a single loaded image (if user chose command *-image*) or from a video stream (if user chose command *-video*). Also, if the user added *log* command at the end of its program call, the spatial logarithmic image sampling performed by the retina is taken into account by the Boolean flag *useLogSampling*.
+
+.. code-block:: cpp
+
+  // welcome message
+    std::cout<<"****************************************************"<<std::endl;
+    std::cout<<"* Retina demonstration : demonstrates the use of is a wrapper class of the Gipsa/Listic Labs retina model."<<std::endl;
+    std::cout<<"* This demo will try to load the file 'RetinaSpecificParameters.xml' (if exists).\nTo create it, copy the autogenerated template 'RetinaDefaultParameters.xml'.\nThen twaek it with your own retina parameters."<<std::endl;
+    // basic input arguments checking
+    if (argc<2)
+    {
+        help("bad number of parameter");
+        return -1;
+    }
+
+    bool useLogSampling = !strcmp(argv[argc-1], "log"); // check if user wants retina log sampling processing
+
+    std::string inputMediaType=argv[1];
+
+    //////////////////////////////////////////////////////////////////////////////
+    // checking input media type (still image, video file, live video acquisition)
+    if (!strcmp(inputMediaType.c_str(), "-image") && argc >= 3)
+    {
+        std::cout<<"RetinaDemo: processing image "<<argv[2]<<std::endl;
+        // image processing case
+        inputFrame = cv::imread(std::string(argv[2]), 1); // load image in RGB mode
+    }else
+        if (!strcmp(inputMediaType.c_str(), "-video"))
+        {
+            if (argc == 2 || (argc == 3 && useLogSampling)) // attempt to grab images from a video capture device
+            {
+                videoCapture.open(0);
+            }else// attempt to grab images from a video filestream
+            {
+                std::cout<<"RetinaDemo: processing video stream "<<argv[2]<<std::endl;
+                videoCapture.open(argv[2]);
+            }
+
+            // grab a first frame to check if everything is ok
+            videoCapture>>inputFrame;
+        }else
+        {
+            // bad command parameter
+            help("bad command parameter");
+            return -1;
+        }
+
+Once all input parameters are processed, a first image should have been loaded, if not, display error and stop program :
+
+.. code-block:: cpp
+
+    if (inputFrame.empty())
+    {
+        help("Input media could not be loaded, aborting");
+        return -1;
+    }
+
+Now, everything is ready to run the retina model. I propose here to allocate a retina instance and to manage the eventual log sampling option. The Retina constructor expects at least a cv::Size object that shows the input data size that will have to be managed. One can activate other options such as color and its related color multiplexing strategy (here Bayer multiplexing is chosen using enum cv::RETINA_COLOR_BAYER). If using log sampling, the image reduction factor (smaller output images) and log sampling strengh can be adjusted.
+
+.. code-block:: cpp
+
+        // pointer to a retina object
+        cv::Ptr<cv::Retina> myRetina;
+
+        // if the last parameter is 'log', then activate log sampling (favour foveal vision and subsamples peripheral vision)
+        if (useLogSampling)
+        {
+            myRetina = new cv::Retina(inputFrame.size(), true, cv::RETINA_COLOR_BAYER, true, 2.0, 10.0);
+        }
+        else// -> else allocate "classical" retina :
+            myRetina = new cv::Retina(inputFrame.size());
+
+
+Once done, the proposed code writes a default xml file that contains the default parameters of the retina. This is useful to make your own config using this template. Here generated template xml file is called *RetinaDefaultParameters.xml*.
+
+.. code-block:: cpp
+
+        // save default retina parameters file in order to let you see this and maybe modify it and reload using method "setup"
+        myRetina->write("RetinaDefaultParameters.xml");
+
+In the following line, the retina attempts to load another xml file called *RetinaSpecificParameters.xml*. If you created it and introduced your own setup, it will be loaded, in the other case, default retina parameters are used.
+
+.. code-block:: cpp
+
+        // load parameters if file exists
+        myRetina->setup("RetinaSpecificParameters.xml");
+
+It is not required here but just to show it is possible, you can reset the retina buffers to zero to force it to forget past events.
+
+.. code-block:: cpp
+
+        // reset all retina buffers (imagine you close your eyes for a long time)
+        myRetina->clearBuffers();
+
+Now, it is time to run the retina ! First create some output buffers ready to receive the two retina channels outputs
+
+.. code-block:: cpp
+
+        // declare retina output buffers
+        cv::Mat retinaOutput_parvo;
+        cv::Mat retinaOutput_magno;
+
+Then, run retina in a loop, load new frames from video sequence if necessary and get retina outputs back to dedicated buffers.
+
+.. code-block:: cpp
+
+        // processing loop with no stop condition
+        while(true)
+        {
+            // if using video stream, then, grabbing a new frame, else, input remains the same
+            if (videoCapture.isOpened())
+                videoCapture>>inputFrame;
+
+            // run retina filter on the loaded input frame
+            myRetina->run(inputFrame);
+            // Retrieve and display retina output
+            myRetina->getParvo(retinaOutput_parvo);
+            myRetina->getMagno(retinaOutput_magno);
+            cv::imshow("retina input", inputFrame);
+            cv::imshow("Retina Parvo", retinaOutput_parvo);
+            cv::imshow("Retina Magno", retinaOutput_magno);
+            cv::waitKey(10);
+        }
+
+That's done ! But if you want to secure the system, take care and manage Exceptions. The retina can throw some when it sees irrelevant data (no input frame, wrong setup, etc.).
+Then, i recommend to surround all the retina code by a try/catch system like this :
+
+.. code-block:: cpp
+
+    try{
+         // pointer to a retina object
+         cv::Ptr<cv::Retina> myRetina;
+         [---]
+         // processing loop with no stop condition
+         while(true)
+         {
+             [---]
+         }
+
+    }catch(cv::Exception e)
+    {
+        std::cerr<<"Error using Retina : "<<e.what()<<std::endl;
+    }
+
+Retina parameters, what to do ?
+===============================
+
+First, it is recommended to read the reference paper :
+
+* Benoit A., Caplier A., Durette B., Herault, J., *"Using Human Visual System Modeling For Bio-Inspired Low Level Image Processing"*, Elsevier, Computer Vision and Image Understanding 114 (2010), pp. 758-773. DOI <http://dx.doi.org/10.1016/j.cviu.2010.01.011>
+
+Once done open the configuration file *RetinaDefaultParameters.xml* generated by the demo and let's have a look at it.
+
+.. code-block:: cpp
+
+        <?xml version="1.0"?>
+        <opencv_storage>
+        <OPLandIPLparvo>
+          <colorMode>1</colorMode>
+          <normaliseOutput>1</normaliseOutput>
+          <photoreceptorsLocalAdaptationSensitivity>7.0e-01</photoreceptorsLocalAdaptationSensitivity>
+          <photoreceptorsTemporalConstant>5.0e-01</photoreceptorsTemporalConstant>
+          <photoreceptorsSpatialConstant>5.3e-01</photoreceptorsSpatialConstant>
+          <horizontalCellsGain>0.</horizontalCellsGain>
+          <hcellsTemporalConstant>1.</hcellsTemporalConstant>
+          <hcellsSpatialConstant>7.</hcellsSpatialConstant>
+          <ganglionCellsSensitivity>7.0e-01</ganglionCellsSensitivity></OPLandIPLparvo>
+        <IPLmagno>
+          <normaliseOutput>1</normaliseOutput>
+          <parasolCells_beta>0.</parasolCells_beta>
+          <parasolCells_tau>0.</parasolCells_tau>
+          <parasolCells_k>7.</parasolCells_k>
+          <amacrinCellsTemporalCutFrequency>1.2e+00</amacrinCellsTemporalCutFrequency>
+          <V0CompressionParameter>9.5e-01</V0CompressionParameter>
+          <localAdaptintegration_tau>0.</localAdaptintegration_tau>
+          <localAdaptintegration_k>7.</localAdaptintegration_k></IPLmagno>
+        </opencv_storage>
+
+
+Here are some hints but actually, the best parameter setup depends more on what you want to do with the retina rather than the images input that you give to retina. Apart from the more specific case of High Dynamic Range images (HDR) that require more specific setup for specific luminance compression objective, the retina behaviors should be rather stable from content to content. Note that OpenCV is able to manage such HDR format thanks to the OpenEXR images compatibility.
+
+Then, if the application target requires details enhancement prior to specific image processing, you need to know if mean luminance information is required or not. If not, the the retina can cancel or significantly reduce its energy thus giving more visibility to higher spatial frequency details.
+
+
+Basic parameters
+----------------
+
+The most simple parameters are the following :
+
+* **colorMode** : let the retina process color information (if 1) or gray scale images (if 0). In this last case, only the first channel of the input will be processed.
+
+* **normaliseOutput** : each channel has this parameter, if value is 1, then the considered channel output is rescaled between 0 and 255. Take care in this case at the Magnocellular output level (motion/transient channel detection). Residual noise will also be rescaled !
+
+**Note :** using color requires color channels multiplexing/demultipexing which requires more processing. You can expect much faster processing using gray levels : it would require around 30 product per pixel for all the retina processes and it has recently been parallelized for multicore architectures.
+
+Photo-receptors parameters
+--------------------------
+
+The following parameters act on the entry point of the retina - photo-receptors - and impact all the following processes. These sensors are low pass spatio-temporal filters that smooth temporal and spatial data and also adjust there sensitivity to local luminance thus improving details extraction and high frequency noise canceling.
+
+* **photoreceptorsLocalAdaptationSensitivity** between 0 and 1. Values close to 1 allow high luminance log compression effect at the photo-receptors level. Values closer to 0 give a more linear sensitivity. Increased alone, it can burn the *Parvo (details channel)* output image. If adjusted in collaboration with **ganglionCellsSensitivity** images can be very contrasted whatever the local luminance there is... at the price of a naturalness decrease.
+
+* **photoreceptorsTemporalConstant** this setups the temporal constant of the low pass filter effect at the entry of the retina. High value lead to strong temporal smoothing effect : moving objects are blurred and can disappear while static object are favored. But when starting the retina processing, stable state is reached lately.
+
+* **photoreceptorsSpatialConstant** specifies the spatial constant related to photo-receptors low pass filter effect. This parameters specify the minimum allowed spatial signal period allowed in the following. Typically, this filter should cut high frequency noise. Then a 0 value doesn't cut anything noise while higher values start to cut high spatial frequencies and more and more lower frequencies... Then, do not go to high if you wanna see some details of the input images ! A good compromise for color images is 0.53 since this won't affect too much the color spectrum. Higher values would lead to gray and blurred output images.
+
+Horizontal cells parameters
+---------------------------
+
+This parameter set tunes the neural network connected to the photo-receptors, the horizontal cells. It modulates photo-receptors sensitivity and completes the processing for final spectral whitening (part of the spatial band pass effect thus favoring visual details enhancement).
+
+* **horizontalCellsGain** here is a critical parameter ! If you are not interested by the mean luminance and focus on details enhancement, then, set to zero. But if you want to keep some environment luminance data, let some low spatial frequencies pass into the system and set a higher value (<1).
+
+* **hcellsTemporalConstant** similar to photo-receptors, this acts on the temporal constant of a low pass temporal filter that smooths input data. Here, a high value generates a high retina after effect while a lower value makes the retina more reactive.
+
+* **hcellsSpatialConstant** is the spatial constant of the low pass filter of these cells filter. It specifies the lowest spatial frequency allowed in the following. Visually, a high value leads to very low spatial frequencies processing and leads to salient halo effects. Lower values reduce this effect but the limit is : do not go lower than the value of **photoreceptorsSpatialConstant**. Those 2 parameters actually specify the spatial band-pass of the retina.
+
+**NOTE** after the processing managed by the previous parameters, input data is cleaned from noise and luminance in already partly enhanced. The following parameters act on the last processing stages of the two outing retina signals.
+
+Parvo (details channel) dedicated parameter
+-------------------------------------------
+
+* **ganglionCellsSensitivity** specifies the strength of the final local adaptation occurring at the output of this details dedicated channel. Parameter values remain between 0 and 1. Low value tend to give a linear response while higher values enforces the remaining low contrasted areas.
+
+**Note :** this parameter can correct eventual burned images by favoring low energetic details of the visual scene, even in bright areas.
+
+IPL Magno (motion/transient channel) parameters
+-----------------------------------------------
+
+Once image information is cleaned, this channel acts as a high pass temporal filter that only selects signals related to transient signals (events, motion, etc.). A low pass spatial filter smooths extracted transient data and a final logarithmic compression enhances low transient events thus enhancing event sensitivity.
+
+* **parasolCells_beta** generally set to zero, can be considered as an amplifier gain at the entry point of this processing stage. Generally set to 0.
+
+* **parasolCells_tau** the temporal smoothing effect that can be added
+
+* **parasolCells_k** the spatial constant of the spatial filtering effect, set it at a high value to favor low spatial frequency signals that are lower subject to residual noise.
+
+* **amacrinCellsTemporalCutFrequency** specifies the temporal constant of the high pass filter. High values let slow transient events to be selected.
+
+* **V0CompressionParameter** specifies the strength of the log compression. Similar behaviors to previous description but here it enforces sensitivity of transient events.
+
+* **localAdaptintegration_tau** generally set to 0, no real use here actually
+
+* **localAdaptintegration_k** specifies the size of the area on which local adaptation is performed. Low values lead to short range local adaptation (higher sensitivity to noise), high values secure log compression.

doc/tutorials/contrib/table_of_content_contrib/table_of_content_contrib.rst

@@ -0,0 +1,36 @@
+.. _Table-Of-Content-Contrib:
+
+*contrib* module. The additional contributions made available !
+----------------------------------------------------------------
+
+Here you will learn how to use additional modules of OpenCV defined in the "contrib" module.
+
+ .. include:: ../../definitions/tocDefinitions.rst
+
++
+  .. tabularcolumns:: m{100pt} m{300pt}
+  .. cssclass:: toctableopencv
+
+  =============== ======================================================
+  |RetinaDemoImg| **Title:** :ref:`Retina_Model`
+
+                  *Compatibility:* > OpenCV 2.4
+
+                  *Author:* |Author_AlexB|
+
+                  You will learn how to process images and video streams with a model of retina filter for details enhancement, spatio-temporal noise removal, luminance correction and spatio-temporal events detection.
+
+  =============== ======================================================
+
+  .. |RetinaDemoImg| image:: images/retina_TreeHdr_small.jpg
+                   :height: 90pt
+                   :width:  90pt
+
+ .. raw:: latex
+
+    \pagebreak
+
+.. toctree::
+   :hidden:
+
+   ../retina_model/retina_model

doc/tutorials/definitions/tocDefinitions.rst

@@ -4,7 +4,8 @@
 .. |Author_LeonidBLB| unicode:: Leonid U+0020 Beynenson
 .. |Author_VsevolodG| unicode:: Vsevolod U+0020 Glumov
 .. |Author_VictorE| unicode:: Victor U+0020 Eruhimov 
-.. |Author_ArtemM| unicode:: Artem U+0020 Myagkov 
-.. |Author_FernandoI| unicode:: Fernando U+0020 Iglesias U+0020 Garc U+00ED a 
+.. |Author_ArtemM| unicode:: Artem U+0020 Myagkov
+.. |Author_FernandoI| unicode:: Fernando U+0020 Iglesias U+0020 Garc U+00ED a
 .. |Author_EduardF| unicode:: Eduard U+0020 Feicho
+.. |Author_AlexB| unicode:: Alexandre U+0020 Benoit
 

doc/tutorials/highgui/video-input-psnr-ssim/video-input-psnr-ssim.rst

@@ -27,9 +27,9 @@ As a test case where to show off these using OpenCV I've created a small program
 How to read a video stream (online-camera or offline-file)?
 ===========================================================
 
-Essentially, all the functionalities required for video manipulation is integrated in the :huivideo:`VideoCapture <videocapture>` C++ class. This on itself builds on the FFmpeg open source library. This is a basic dependency of OpenCV so you shouldn't need to worry about this. A video is composed of a succession of images, we refer to these in the literature as frames. In case of a video file there is a *frame rate* specifying just how long is between two frames. While for the video cameras usually there is a limit of just how many frames they can digitalize per second, this property is less important as at any time the camera sees the current snapshot of the world. 
+Essentially, all the functionalities required for video manipulation is integrated in the :hgvideo:`VideoCapture <videocapture>` C++ class. This on itself builds on the FFmpeg open source library. This is a basic dependency of OpenCV so you shouldn't need to worry about this. A video is composed of a succession of images, we refer to these in the literature as frames. In case of a video file there is a *frame rate* specifying just how long is between two frames. While for the video cameras usually there is a limit of just how many frames they can digitalize per second, this property is less important as at any time the camera sees the current snapshot of the world.
 
-The first task you need to do is to assign to a :huivideo:`VideoCapture <videocapture>` class its source. You can do this either via the :huivideo:`constructor <videocapture-videocapture>` or its :huivideo:`open <videocapture-open>` function. If this argument is an integer then you will bind the class to a camera, a device. The number passed here is the ID of the device, assigned by the operating system. If you have a single camera attached to your system its ID will probably be zero and further ones increasing from there. If the parameter passed to these is a string it will refer to a video file, and the string points to the location and name of the file. For example, to the upper source code a valid command line is: 
+The first task you need to do is to assign to a :hgvideo:`VideoCapture <videocapture>` class its source. You can do this either via the :hgvideo:`constructor <videocapture-videocapture>` or its :hgvideo:`open <videocapture-open>` function. If this argument is an integer then you will bind the class to a camera, a device. The number passed here is the ID of the device, assigned by the operating system. If you have a single camera attached to your system its ID will probably be zero and further ones increasing from there. If the parameter passed to these is a string it will refer to a video file, and the string points to the location and name of the file. For example, to the upper source code a valid command line is:
 
 .. code-block:: bash
 
@@ -46,7 +46,7 @@ We do a similarity check. This requires a reference and a test case video file.
    VideoCapture captUndTst;
    captUndTst.open(sourceCompareWith);
 
-To check if the binding of the class to a video source was successful or not use the :huivideo:`isOpened <video-isopened>` function:
+To check if the binding of the class to a video source was successful or not use the :hgvideo:`isOpened <video-isopened>` function:
 
 .. code-block:: cpp
 
@@ -56,7 +56,7 @@ To check if the binding of the class to a video source was successful or not use
      return -1;
      }
 
-Closing the video is automatic when the objects destructor is called. However, if you want to close it before this you need to call its :huivideo:`release <videocapture-release>` function. The frames of the video are just simple images. Therefore, we just need to extract them from the :huivideo:`VideoCapture <videocapture>` object and put them inside a *Mat* one. The video streams are sequential. You may get the frames one after another by the :huivideo:`read <videocapture-read>` or the overloaded >> operator: 
+Closing the video is automatic when the objects destructor is called. However, if you want to close it before this you need to call its :hgvideo:`release <videocapture-release>` function. The frames of the video are just simple images. Therefore, we just need to extract them from the :hgvideo:`VideoCapture <videocapture>` object and put them inside a *Mat* one. The video streams are sequential. You may get the frames one after another by the :hgvideo:`read <videocapture-read>` or the overloaded >> operator:
 
 .. code-block:: cpp
 
@@ -73,9 +73,9 @@ The upper read operations will leave empty the *Mat* objects if no frame could b
     // exit the program
    }
 
-A read method is made of a frame grab and a decoding applied on that. You may call explicitly these two by using the :huivideo:`grab <videocapture-grab>` and then the :huivideo:`retrieve <videocapture-retrieve>` functions. 
+A read method is made of a frame grab and a decoding applied on that. You may call explicitly these two by using the :hgvideo:`grab <videocapture-grab>` and then the :hgvideo:`retrieve <videocapture-retrieve>` functions.
 
-Videos have many-many information attached to them besides the content of the frames. These are usually numbers, however in some case it may be short character sequences (4 bytes or less). Due to this to acquire these information there is a general function named :huivideo:`get <videocapture-get>` that returns double values containing these properties. Use bitwise operations to decode the characters from a double type and conversions where valid values are only integers. Its single argument is the ID of the queried property. For example, here we get the size of the frames in the reference and test case video file; plus the number of frames inside the reference. 
+Videos have many-many information attached to them besides the content of the frames. These are usually numbers, however in some case it may be short character sequences (4 bytes or less). Due to this to acquire these information there is a general function named :hgvideo:`get <videocapture-get>` that returns double values containing these properties. Use bitwise operations to decode the characters from a double type and conversions where valid values are only integers. Its single argument is the ID of the queried property. For example, here we get the size of the frames in the reference and test case video file; plus the number of frames inside the reference.
 
 .. code-block:: cpp
 
@@ -85,7 +85,7 @@ Videos have many-many information attached to them besides the content of the fr
    cout << "Reference frame resolution: Width=" << refS.width << "  Height=" << refS.height
         << " of nr#: " << captRefrnc.get(CV_CAP_PROP_FRAME_COUNT) << endl;
 
-When you are working with videos you may often want to control these values yourself. To do this there is a :huivideo:`set <videocapture-set>` function. Its first argument remains the name of the property you want to change and there is a second of double type containing the value to be set. It will return true if it succeeds and false otherwise. Good examples for this is seeking in a video file to a given time or frame: 
+When you are working with videos you may often want to control these values yourself. To do this there is a :hgvideo:`set <videocapture-set>` function. Its first argument remains the name of the property you want to change and there is a second of double type containing the value to be set. It will return true if it succeeds and false otherwise. Good examples for this is seeking in a video file to a given time or frame:
 
 .. code-block:: cpp
 
@@ -93,7 +93,7 @@ When you are working with videos you may often want to control these values your
    captRefrnc.set(CV_CAP_PROP_POS_FRAMES, 10); // go to the 10th frame of the video
    // now a read operation would read the frame at the set position
 
-For properties you can read and change look into the documentation of the :huivideo:`get <videocapture-get>` and :huivideo:`set <videocapture-set>` functions. 
+For properties you can read and change look into the documentation of the :hgvideo:`get <videocapture-get>` and :hgvideo:`set <videocapture-set>` functions.
 
 
 Image similarity - PSNR and SSIM

doc/tutorials/highgui/video-write/video-write.rst

@@ -1,90 +1,137 @@
 .. _videoWriteHighGui:
+
 Creating a video with OpenCV
 ****************************
+
 Goal
 ====
-Whenever you work with video feeds you may eventually want to save your image processing result in a form of a new video file. For simple video outputs you can use the OpenCV built-in :huivideo:`VideoWriter <videowriter-videowriter>` class, designed for this.
+
+Whenever you work with video feeds you may eventually want to save your image processing result in a form of a new video file. For simple video outputs you can use the OpenCV built-in :hgvideo:`VideoWriter <videowriter-videowriter>` class, designed for this.
+
 .. container:: enumeratevisibleitemswithsquare
+
    + How to create a video file with OpenCV
    + What type of video files you can create with OpenCV
    + How to extract a given color channel from a video
+
 As a simple demonstration I'll just extract one of the RGB color channels of an input video file into a new video. You can control the flow of the application from its console line arguments:
+
 .. container:: enumeratevisibleitemswithsquare
+
    + The first argument points to the video file to work on
    + The second argument may be one of the characters: R G B. This will specify which of the channels to extract.
    + The last argument is the character Y (Yes) or N (No). If this is no, the codec used for the input video file will be the same as for the output. Otherwise, a window will pop up and allow you to select yourself the codec to use.
+
 For example, a valid command line would look like:
+
 .. code-block:: bash
+
    video-write.exe video/Megamind.avi R Y
+
 The source code
 ===============
 You may also find the source code and these video file in the :file:`samples/cpp/tutorial_code/highgui/video-write/` folder of the OpenCV source library or :download:`download it from here <../../../../samples/cpp/tutorial_code/HighGUI/video-write/video-write.cpp>`.
+
 .. literalinclude:: ../../../../samples/cpp/tutorial_code/HighGUI/video-write/video-write.cpp
    :language: cpp
    :linenos:
    :tab-width: 4
    :lines: 1-8, 21-22, 24-97
+
 The structure of a video
 ========================
 For start, you should have an idea of just how a video file looks. Every video file in itself is a container. The type of the container is expressed in the files extension (for example *avi*, *mov* or *mkv*). This contains multiple elements like: video feeds, audio feeds or other tracks (like for example subtitles). How these feeds are stored is determined by the codec used for each one of them. In case of the audio tracks commonly used codecs are *mp3* or *aac*. For the video files the list is somehow longer and includes names such as *XVID*, *DIVX*, *H264* or *LAGS* (*Lagarith Lossless Codec*). The full list of codecs you may use on a system depends on just what one you have installed.
+
 .. image:: images/videoFileStructure.png
    :alt: The Structure of the video
    :align: center
+
 As you can see things can get really complicated with videos. However, OpenCV is mainly a computer vision library, not a video stream, codec and write one. Therefore, the developers tried to keep this part as simple as possible. Due to this OpenCV for video containers supports only the *avi* extension, its first version. A direct limitation of this is that you cannot save a video file larger than 2 GB. Furthermore you can only create and expand a single video track inside the container. No audio or other track editing support here. Nevertheless, any video codec present on your system might work. If you encounter some of these limitations you will need to look into more specialized video writing libraries such as *FFMpeg* or codecs as *HuffYUV*, *CorePNG* and *LCL*. As an alternative, create the video track with OpenCV and expand it with sound tracks or convert it to other formats by using video manipulation programs such as *VirtualDub* or *AviSynth*.
 The *VideoWriter* class
 =======================
 The content written here builds on the assumption you already read the :ref:`videoInputPSNRMSSIM` tutorial and you know how to read video files.
-To create a video file you just need to create an instance of the :huivideo:`VideoWriter <videowriter-videowriter>` class. You can specify its properties either via parameters in the constructor or later on via the :huivideo:`open <videowriter-open>` function. Either way, the parameters are the same:
+To create a video file you just need to create an instance of the :hgvideo:`VideoWriter <videowriter-videowriter>` class. You can specify its properties either via parameters in the constructor or later on via the :hgvideo:`open <videowriter-open>` function. Either way, the parameters are the same:
 1. The name of the output that contains the container type in its extension. At the moment only *avi* is supported. We construct this from the input file, add to this the name of the channel to use, and finish it off with the container extension.
+
    .. code-block:: cpp
+
       const string source      = argv[1];            // the source file name
       string::size_type pAt = source.find_last_of('.');   // Find extension point
       const string NAME = source.substr(0, pAt) + argv[2][0] + ".avi";   // Form the new name with container
+
 #. The codec to use for the video track. Now all the video codecs have a unique short name of maximum four characters. Hence, the *XVID*, *DIVX* or *H264* names. This is called a four character code. You may also ask this from an input video by using its *get* function. Because the *get* function is a general function it always returns double values. A double value is stored on 64 bits. Four characters are four bytes, meaning 32 bits. These four characters are coded in the lower 32 bits of the *double*. A simple way to throw away the upper 32 bits would be to just convert this value to *int*:
+
    .. code-block:: cpp
+
       VideoCapture inputVideo(source);                                   // Open input
       int ex = static_cast<int>(inputVideo.get(CV_CAP_PROP_FOURCC));     // Get Codec Type- Int form
+
    OpenCV internally works with this integer type and expect this as its second parameter. Now to convert from the integer form to string we may use two methods: a bitwise operator and a union method. The first one extracting from an int the characters looks like (an "and" operation, some shifting and adding a 0 at the end to close the string):
+
    .. code-block:: cpp
+
       char EXT[] = {ex & 0XFF , (ex & 0XFF00) >> 8,(ex & 0XFF0000) >> 16,(ex & 0XFF000000) >> 24, 0};
+
    You can do the same thing with the *union* as:
+
    .. code-block:: cpp
+
       union { int v; char c[5];} uEx ;
       uEx.v = ex;                              // From Int to char via union
       uEx.c[4]='\0';
+
    The advantage of this is that the conversion is done automatically after assigning, while for the bitwise operator you need to do the operations whenever you change the codec type. In case you know the codecs four character code beforehand, you can use the *CV_FOURCC* macro to build the integer:
+
    .. code-block::cpp
+
       CV_FOURCC('P','I','M,'1') // this is an MPEG1 codec from the characters to integer
+
    If you pass for this argument minus one than a window will pop up at runtime that contains all the codec installed on your system and ask you to select the one to use:
+
    .. image:: images/videoCompressSelect.png
       :alt: Select the codec type to use
       :align: center
+
 #. The frame per second for the output video. Again, here I keep the input videos frame per second by using the *get* function.
 #. The size of the frames for the output video. Here too I keep the input videos frame size per second by using the *get* function.
 #. The final argument is an optional one. By default is true and says that the output will be a colorful one (so for write you will send three channel images). To create a gray scale video pass a false parameter here.
+
 Here it is, how I use it in the sample:
+
+    .. code-block:: cpp
+
+       VideoWriter outputVideo;
+       Size S = Size((int) inputVideo.get(CV_CAP_PROP_FRAME_WIDTH),    //Acquire input size
+                     (int) inputVideo.get(CV_CAP_PROP_FRAME_HEIGHT));
+       outputVideo.open(NAME , ex, inputVideo.get(CV_CAP_PROP_FPS),S, true);
+
+Afterwards, you use the :hgvideo:`isOpened() <videowriter-isopened>` function to find out if the open operation succeeded or not. The video file automatically closes when the *VideoWriter* object is destroyed. After you open the object with success you can send the frames of the video in a sequential order by using the :hgvideo:`write<videowriter-write>` function of the class. Alternatively, you can use its overloaded operator << :
+
 .. code-block:: cpp
-   VideoWriter outputVideo;
-   Size S = Size((int) inputVideo.get(CV_CAP_PROP_FRAME_WIDTH),    //Acquire input size
-                 (int) inputVideo.get(CV_CAP_PROP_FRAME_HEIGHT));
-   outputVideo.open(NAME , ex, inputVideo.get(CV_CAP_PROP_FPS),S, true);
-Afterwards, you use the :huivideo:`isOpened() <videowriter-isopened>` function to find out if the open operation succeeded or not. The video file automatically closes when the *VideoWriter* object is destroyed. After you open the object with success you can send the frames of the video in a sequential order by using the :huivideo:`write<videowriter-write>` function of the class. Alternatively, you can use its overloaded operator << :
-.. code-block:: cpp
+
     outputVideo.write(res);  //or
     outputVideo << res;
+
 Extracting a color channel from an RGB image means to set to zero the RGB values of the other channels. You can either do this with image scanning operations or by using the split and merge operations. You first split the channels up into different images, set the other channels to zero images of the same size and type and finally merge them back:
+
 .. code-block:: cpp
+
    split(src, spl);                 // process - extract only the correct channel
    for( int i =0; i < 3; ++i)
       if (i != channel)
          spl[i] = Mat::zeros(S, spl[0].type());
    merge(spl, res);
+
 Put all this together and you'll get the upper source code, whose runtime result will show something around the idea:
+
 .. image:: images/resultOutputWideoWrite.png
    :alt: A sample output
    :align: center
+
 You may observe a runtime instance of this on the `YouTube here <https://www.youtube.com/watch?v=jpBwHxsl1_0>`_.
+
 .. raw:: html
+
   <div align="center">
   <iframe title="Creating a video with OpenCV" width="560" height="349" src="http://www.youtube.com/embed/jpBwHxsl1_0?rel=0&loop=1" frameborder="0" allowfullscreen align="middle"></iframe>
-  </div>
+  </div>

doc/tutorials/introduction/android_binary_package/O4A_SDK.rst

@@ -7,9 +7,10 @@ OpenCV4Android SDK
 
 This tutorial was designed to help you with installation and configuration of OpenCV4Android SDK.
 
-This guide was written with MS Windows 7 in mind, though it should work with GNU Linux and Apple MacOS as well.
+This guide was written with MS Windows 7 in mind, though it should work with GNU Linux and Apple
+Mac OS as well.
 
-This tutorial assumes you have the following installed and configured:
+This tutorial assumes you have the following software installed and configured:
 
 * JDK
 
@@ -23,7 +24,20 @@ This tutorial assumes you have the following installed and configured:
 
 If you need help with anything of the above, you may refer to our :ref:`android_dev_intro` guide.
 
-If you encounter any error after thoroughly following these steps, feel free to contact us via `OpenCV4Android <https://groups.google.com/group/android-opencv/>`_ discussion group or OpenCV `Q&A forum <http://answers.opencv.org>`_. We'll do our best to help you out.
+If you encounter any error after thoroughly following these steps, feel free to contact us via
+`OpenCV4Android <https://groups.google.com/group/android-opencv/>`_ discussion group or
+OpenCV `Q&A forum <http://answers.opencv.org>`_. We'll do our best to help you out.
+
+Tegra Android Development Pack users
+====================================
+
+You may have used `Tegra Android Development Pack <http://developer.nvidia.com/tegra-android-development-pack>`_
+(**TADP**) released by **NVIDIA** for Android development environment setup.
+
+Beside Android development tools the TADP 2.0 includes OpenCV4Android SDK, so it can be already
+installed in your system and you can skip to :ref:`Running_OpenCV_Samples` section of this tutorial.
+
+More details regarding TADP can be found in the :ref:`android_dev_intro` guide.
 
 General info
 ============
@@ -57,32 +71,44 @@ The structure of package contents looks as follows:
 
 * :file:`sdk` folder contains OpenCV API and libraries for Android:
 
-* :file:`sdk/java` folder contains an Android library Eclipse project providing OpenCV Java API that can be imported into developer's workspace;
+* :file:`sdk/java` folder contains an Android library Eclipse project providing OpenCV Java API that
+  can be imported into developer's workspace;
 
-* :file:`sdk/native` folder contains OpenCV C++ headers (for JNI code) and native Android libraries (\*\.so and \*\.a) for ARM-v5, ARM-v7a and x86 architectures;
+* :file:`sdk/native` folder contains OpenCV C++ headers (for JNI code) and native Android libraries
+  (\*\.so and \*\.a) for ARM-v5, ARM-v7a and x86 architectures;
 
 * :file:`sdk/etc` folder contains Haar and LBP cascades distributed with OpenCV.
 
-* :file:`apk` folder contains Android packages that should be installed on the target Android device to enable OpenCV library access via OpenCV Manager API (see details below).
+* :file:`apk` folder contains Android packages that should be installed on the target Android device
+  to enable OpenCV library access via OpenCV Manager API (see details below).
 
-  On production devices that have access to Google Play Market (and internet) these packages will be installed from Market on the first start of an application using OpenCV Manager API.
-  But dev kits without Market or internet require this packages to be installed manually.
-  (Install the `Manager.apk` and the corresponding `binary_pack.apk` depending on the device CPU, the Manager GUI provides this info).
+  On production devices that have access to Google Play Market (and Internet) these packages will be
+  installed from Market on the first start of an application using OpenCV Manager API.
+  But devkits without Market or Internet connection require this packages to be installed manually.
+  Install the `Manager.apk` and the corresponding `binary_pack.apk` depending on the device CPU,
+  the Manager GUI provides this info. Below you'll see exact commands on how to do this.
 
-  **Note**: installation from internet is the preferable way since we may publish updated versions of this packages on the Market.
+  .. note:: Installation from Internet is the preferable way since OpenCV team may publish updated
+            versions of this packages on the Market.
 
 * :file:`samples` folder contains sample applications projects and their prebuilt packages (APK).
-  Import them into Eclipse workspace (like described below) and browse the code to learn possible ways of OpenCV use on Android.
+  Import them into Eclipse workspace (like described below) and browse the code to learn possible
+  ways of OpenCV use on Android.
 
 * :file:`doc` folder contains various OpenCV documentation in PDF format.
   It's also available online at http://docs.opencv.org.
 
-  **Note**: the most recent docs (nightly build) are at http://docs.opencv.org/trunk/.
-  Generally, it's more up-to-date, but can refer to not-yet-released functionality.
+  .. note:: The most recent docs (nightly build) are at http://docs.opencv.org/trunk/.
+            Generally, it's more up-to-date, but can refer to not-yet-released functionality.
 
-Starting version 2.4.3 `OpenCV4Android SDK` uses `OpenCV Manager` API for library initialization. `OpenCV Manager` is an Android service based solution providing the following benefits for OpenCV applications developers:
+.. TODO: I'm not sure that this is the best place to talk about OpenCV Manager
 
-* Compact apk-size, since all applications use the same binaries from Manager and do not store native libs within themselves;
+Starting from version 2.4.3 `OpenCV4Android SDK` uses `OpenCV Manager` API for library
+initialization. `OpenCV Manager` is an Android service based solution providing the following
+benefits for OpenCV applications developers:
+
+* Compact apk-size, since all applications use the same binaries from Manager and do not store
+  native libs within themselves;
 
 * Hardware specific optimizations are automatically enabled on all supported platforms;
 
@@ -92,7 +118,6 @@ Starting version 2.4.3 `OpenCV4Android SDK` uses `OpenCV Manager` API for librar
 
      ..
 
-
 For additional information on OpenCV Manager see the:
 
 * |OpenCV4Android_Slides|_
@@ -106,29 +131,21 @@ For additional information on OpenCV Manager see the:
 .. |OpenCV4Android_Reference| replace:: Reference Manual
 .. _OpenCV4Android_Reference: http://docs.opencv.org/android/refman.html
 
-Tegra Android Development Pack users
-====================================
-
-You may have used `Tegra Android Development Pack <http://developer.nvidia.com/tegra-android-development-pack>`_
-(**TADP**) released by **NVIDIA** for Android development environment setup.
-
-Beside Android development tools the TADP 2.0 includes OpenCV4Android SDK 2.4.2, so it can be already installed in your system and you can skip to running the ``face-detection`` sample.
-
-More details regarding TADP can be found in the :ref:`android_dev_intro` guide.
-
 Manual OpenCV4Android SDK setup
 ===============================
 
 Get the OpenCV4Android SDK
 --------------------------
 
-#. Go to the `OpenCV dowload page on SourceForge <http://sourceforge.net/projects/opencvlibrary/files/opencv-android/>`_ and download the latest available version. Currently it's |opencv_android_bin_pack_url|_
+#. Go to the `OpenCV download page on SourceForge <http://sourceforge.net/projects/opencvlibrary/files/opencv-android/>`_
+   and download the latest available version. Currently it's |opencv_android_bin_pack_url|_.
 
-#. Create a new folder for Android with OpenCV development. For this tutorial I have unpacked OpenCV to the :file:`C:\\Work\\OpenCV4Android\\` directory.
+#. Create a new folder for Android with OpenCV development. For this tutorial we have unpacked
+   OpenCV SDK to the :file:`C:\\Work\\OpenCV4Android\\` directory.
 
-      .. note:: Better to use a path without spaces in it. Otherwise you may have problems with :command:`ndk-build`.
+   .. note:: Better to use a path without spaces in it. Otherwise you may have problems with :command:`ndk-build`.
 
-#. Unpack the OpenCV package into the chosen directory.
+#. Unpack the SDK archive into the chosen directory.
 
    You can unpack it using any popular archiver (e.g with |seven_zip|_):
 
@@ -148,12 +165,13 @@ Get the OpenCV4Android SDK
 .. |seven_zip| replace:: 7-Zip
 .. _seven_zip: http://www.7-zip.org/
 
-Open OpenCV library and samples in Eclipse
-------------------------------------------
+Import OpenCV library and samples to the Eclipse
+------------------------------------------------
 
-#. Start *Eclipse* and choose your workspace location.
+#. Start Eclipse and choose your workspace location.
 
-   We recommend to start working with OpenCV for Android from a new clean workspace. A new Eclipse workspace can for example be created in the folder where you have unpacked OpenCV4Android SDK package:
+   We recommend to start working with OpenCV for Android from a new clean workspace. A new Eclipse
+   workspace can for example be created in the folder where you have unpacked OpenCV4Android SDK package:
 
       .. image:: images/eclipse_1_choose_workspace.png
          :alt: Choosing C:\Work\android-opencv\ as workspace location
@@ -162,24 +180,28 @@ Open OpenCV library and samples in Eclipse
 #. Import OpenCV library and samples into workspace.
 
    OpenCV library is packed as a ready-for-use `Android Library Project
-   <http://developer.android.com/guide/developing/projects/index.html#LibraryProjects>`_. You can simply reference it in your projects.
+   <http://developer.android.com/guide/developing/projects/index.html#LibraryProjects>`_.
+   You can simply reference it in your projects.
 
-   Each sample included into the |opencv_android_bin_pack| is a regular Android project that already references OpenCV library.
-   Follow the steps below to import OpenCV and samples into the workspace:
+   Each sample included into the |opencv_android_bin_pack| is a regular Android project that already
+   references OpenCV library.Follow the steps below to import OpenCV and samples into the workspace:
 
-   * Right click on the :guilabel:`Package Explorer` window and choose :guilabel:`Import...` option from the context menu:
+   * Right click on the :guilabel:`Package Explorer` window and choose :guilabel:`Import...` option
+     from the context menu:
 
       .. image:: images/eclipse_5_import_command.png
          :alt: Select Import... from context menu
          :align: center
 
-   * In the main panel select :menuselection:`General --> Existing Projects into Workspace` and press :guilabel:`Next` button:
+   * In the main panel select :menuselection:`General --> Existing Projects into Workspace` and
+     press :guilabel:`Next` button:
 
       .. image:: images/eclipse_6_import_existing_projects.png
          :alt: General > Existing Projects into Workspace
          :align: center
 
-   * In the :guilabel:`Select root directory` field locate your OpenCV package folder. Eclipse should automatically locate OpenCV library and samples:
+   * In the :guilabel:`Select root directory` field locate your OpenCV package folder. Eclipse
+     should automatically locate OpenCV library and samples:
 
       .. image:: images/eclipse_7_select_projects.png
          :alt: Locate OpenCV library and samples
@@ -187,34 +209,20 @@ Open OpenCV library and samples in Eclipse
 
    * Click :guilabel:`Finish` button to complete the import operation.
 
-   After clicking :guilabel:`Finish` button Eclipse will load all selected projects into workspace. Numerous errors will be indicated:
+   After clicking :guilabel:`Finish` button Eclipse will load all selected projects into workspace,
+   and you have to wait some time while it is building OpenCV samples. Just give a minute to
+   Eclipse to complete initialization.
 
-      .. image:: images/eclipse_8_false_alarm.png
-         :alt: Confusing Eclipse screen with numerous errors
-         :align: center
+   .. note :: After the initial import, on a non-Windows (Linux and Mac OS) operating system Eclipse
+              will still show build errors for applications with native C++ code. To resolve the
+              issues, please do the following:
 
-   However, **all these errors are only false-alarms**!
+              Open :guilabel:`Project Properties -> C/C++ Build`, and replace "Build command" text
+              to ``"${NDKROOT}/ndk-build"`` (remove .cmd at the end).
 
-   Just give a minute to Eclipse to complete initialization.
-
-   In some cases these errors disappear after :menuselection:`Project --> Clean... --> Clean all --> OK`
-   or after pressing :kbd:`F5` (for Refresh action) when selecting error-label-marked projects in :guilabel:`Package Explorer`.
-
-   Sometimes more advanced manipulations are required:
-
-   The provided projects are configured for ``API 11`` target (and ``API 9`` for the library) that can be missing platform in your Android SDK.
-   After right click on any project select  :guilabel:`Properties` and then :guilabel:`Android` on the left pane.
-   Click some target with `API Level` 11 or higher:
-
-      .. image:: images/eclipse_8a_target.png
-         :alt: Updating target
-         :align: center
-
-   Eclipse will rebuild your workspace and error icons will disappear one by one:
-
-      .. image:: images/eclipse_9_errors_dissapearing.png
-         :alt: After small help Eclipse removes error icons!
-         :align: center
+   .. image:: images/eclipse_cdt_cfg4.png
+      :alt: Configure CDT
+      :align: center
 
    Once Eclipse completes build you will have the clean workspace without any build errors:
 
@@ -227,13 +235,17 @@ Open OpenCV library and samples in Eclipse
 Running OpenCV Samples
 ----------------------
 
-At this point you should be able to build and run the samples. Keep in mind, that ``face-detection``, ``Tutorial 3`` and ``Tutorial 4`` include some native code and require Android NDK and CDT plugin for Eclipse to build working applications.
-If you haven't installed these tools see the corresponding section of :ref:`Android_Dev_Intro`.
+At this point you should be able to build and run the samples. Keep in mind, that ``face-detection``,
+``Tutorial 3`` and ``Tutorial 4`` include some native code and require Android NDK and CDT plugin
+for Eclipse to build working applications. If you haven't installed these tools see the corresponding
+section of :ref:`Android_Dev_Intro`.
 
-Also, please consider that ``Tutorial 0`` and ``Tutorial 1`` samples use Java Camera API that definitelly accessible on emulator from the Android SDK.
+Also, please consider that ``Tutorial 0`` and ``Tutorial 1`` samples use Java Camera API that
+definitelly accessible on emulator from the Android SDK.
 Other samples use OpenCV Native Camera which may not work with emulator.
 
-.. note:: Recent *Android SDK tools, revision 19+* can run ARM v7a OS images but they available not for all Android versions.
+.. note:: Recent *Android SDK tools, revision 19+* can run ARM v7a OS images but they available not
+          for all Android versions.
 
 Well, running samples from Eclipse is very simple:
 
@@ -245,7 +257,8 @@ Well, running samples from Eclipse is very simple:
     <http://developer.android.com/guide/developing/device.html>`_ for help with real devices (not emulators).
 
 
-* Select project you want to start in :guilabel:`Package Explorer` and just press :kbd:`Ctrl + F11` or select option :menuselection:`Run --> Run` from the main menu, or click :guilabel:`Run` button on the toolbar.
+* Select project you want to start in :guilabel:`Package Explorer` and just press :kbd:`Ctrl + F11`
+  or select option :menuselection:`Run --> Run` from the main menu, or click :guilabel:`Run` button on the toolbar.
 
   .. note:: Android Emulator can take several minutes to start. So, please, be patient.
 

doc/tutorials/introduction/android_binary_package/android_dev_intro.rst

@@ -5,47 +5,63 @@
 Introduction into Android Development
 *************************************
 
-This guide was designed to help you in learning Android development basics and seting up your working environment quickly.
+This guide was designed to help you in learning Android development basics and seting up your
+working environment quickly. It was written with Windows 7 in mind, though it would work with Linux
+(Ubuntu), Mac OS X and any other OS supported by Android SDK.
 
-This guide was written with Windows 7 in mind, though it would work with Linux (Ubuntu), Mac OS X and any other OS supported by Android SDK.
-
-If you encounter any error after thoroughly following these steps, feel free to contact us via `OpenCV4Android <https://groups.google.com/group/android-opencv/>`_ discussion group or OpenCV `Q&A forum <http://answers.opencv.org>`_. We'll do our best to help you out.
+If you encounter any error after thoroughly following these steps, feel free to contact us via
+`OpenCV4Android <https://groups.google.com/group/android-opencv/>`_ discussion group or
+OpenCV `Q&A forum <http://answers.opencv.org>`_. We'll do our best to help you out.
 
 Preface
 =======
-Android is a Linux-based, open source mobile operating system developed by Open Handset Alliance led by Google. See the `Android home site <http://www.android.com/about/>`_ for general details.
+Android is a Linux-based, open source mobile operating system developed by Open Handset Alliance
+led by Google. See the `Android home site <http://www.android.com/about/>`_ for general details.
 
 Development for Android significantly differs from development for other platforms.
-So before starting programming for Android we recommend you make sure that you are familiar with the following key topis:
+So before starting programming for Android we recommend you make sure that you are familiar with the
+following key topis:
+
+#. `Java <http://en.wikipedia.org/wiki/Java_(programming_language)>`_ programming language that is
+   the primary development technology for Android OS. Also, you can find
+   `Oracle docs on Java <http://docs.oracle.com/javase/>`_ useful.
+#. `Java Native Interface (JNI) <http://en.wikipedia.org/wiki/Java_Native_Interface>`_ that is a
+   technology of running native code in Java virtual machine. Also, you can find
+   `Oracle docs on JNI <http://docs.oracle.com/javase/7/docs/technotes/guides/jni/>`_ useful.
+#. `Android Activity <http://developer.android.com/training/basics/activity-lifecycle/starting.html>`_
+   and its lifecycle, that is an essential Android API class.
+#. OpenCV development will certainly require some knowlege of the
+   `Android Camera <http://developer.android.com/guide/topics/media/camera.html>`_ specifics.
 
-#. `Java <http://en.wikipedia.org/wiki/Java_(programming_language)>`_ programming language that is the primary development technology for Android OS. Also, you can find `Oracle docs on Java <http://docs.oracle.com/javase/>`_ useful.
-#. `Java Native Interface (JNI) <http://en.wikipedia.org/wiki/Java_Native_Interface>`_ that is a technology of running native code in Java virtual machine. Also, you can find `Oracle docs on JNI <http://docs.oracle.com/javase/7/docs/technotes/guides/jni/>`_ useful.
-#. `Android Activity <http://developer.android.com/training/basics/activity-lifecycle/starting.html>`_ and its lifecycle, that is an essential Android API class.
-#. OpenCV development will certainly require some knowlege of the `Android Camera <http://developer.android.com/guide/topics/media/camera.html>`_ specifics.
 
 Quick environment setup for Android development
 ===============================================
 
-If you are making a clean environment install, then you can try `Tegra Android Development Pack <http://developer.nvidia.com/mobile/tegra-android-development-pack>`_
+If you are making a clean environment install, then you can try `Tegra Android Development Pack <https://developer.nvidia.com/tegra-android-development-pack>`_
 (**TADP**) released by **NVIDIA**.
 
+  .. note:: Starting the *version 2.0* the TADP package includes *OpenCV for Tegra* SDK that is a regular *OpenCV4Android SDK* extended with Tegra-specific stuff.
+
 When unpacked, TADP will cover all of the environment setup automatically and you can skip the rest of the guide.
 
 If you are a beginner in Android development then we also recommend you to start with TADP.
 
-.. note:: *NVIDIA*\ 's Tegra Android Development Pack includes some special features for |Nvidia_Tegra_Platform|_ but its use is not limited to *Tegra* devices only.
+  .. note:: *NVIDIA*\ 's Tegra Android Development Pack includes some special features for
+            |Nvidia_Tegra_Platform|_ but its use is not limited to *Tegra* devices only.
 
-  * You need at least *1.6 Gb* free disk space for the install.
+* You need at least *1.6 Gb* free disk space for the install.
 
-  * TADP will download Android SDK platforms and Android NDK from Google's server, so Internet connection is required for the installation.
+* TADP will download Android SDK platforms and Android NDK from Google's server, so Internet
+  connection is required for the installation.
 
-  * TADP may ask you to flash your development kit at the end of installation process. Just skip this step if you have no |Tegra_Development_Kit|_\ .
+* TADP may ask you to flash your development kit at the end of installation process. Just skip
+  this step if you have no |Tegra_Development_Kit|_\ .
 
-  * (``UNIX``) TADP will ask you for *root* in the middle of installation, so you need to be a member of *sudo* group.
+* (``UNIX``) TADP will ask you for *root* in the middle of installation, so you need to be a
+  member of *sudo* group.
 
      ..
 
-
 .. |Nvidia_Tegra_Platform| replace:: *NVIDIA*\ ’s Tegra platform
 .. _Nvidia_Tegra_Platform: http://www.nvidia.com/object/tegra-3-processor.html
 .. |Tegra_Development_Kit| replace:: Tegra Development Kit
@@ -53,6 +69,7 @@ If you are a beginner in Android development then we also recommend you to start
 
 .. _Android_Environment_Setup_Lite:
 
+
 Manual environment setup for Android development
 ================================================
 
@@ -63,19 +80,22 @@ You need the following software to be installed in order to develop for Android
 
 #. **Sun JDK 6**
 
-   Visit `Java SE Downloads page <http://www.oracle.com/technetwork/java/javase/downloads/>`_ and download an installer for your OS.
+   Visit `Java SE Downloads page <http://www.oracle.com/technetwork/java/javase/downloads/>`_
+   and download an installer for your OS.
 
-   Here is a detailed :abbr:`JDK (Java Development Kit)` `installation guide <http://source.android.com/source/initializing.html#installing-the-jdk>`_
+   Here is a detailed :abbr:`JDK (Java Development Kit)`
+   `installation guide <http://source.android.com/source/initializing.html#installing-the-jdk>`_
    for Ubuntu and Mac OS (only JDK sections are applicable for OpenCV)
 
    .. note:: OpenJDK is not suitable for Android development, since Android SDK supports only Sun JDK.
-        If you use Ubuntu, after installation of Sun JDK you should run the following command to set Sun java environment:
+        If you use Ubuntu, after installation of Sun JDK you should run the following command to set
+        Sun java environment:
 
         .. code-block:: bash
 
            sudo update-java-alternatives --set java-6-sun
 
-..   **TODO:** add a note on Sun/Oracle Java installation on Ubuntu 12.
+   .. TODO: Add a note on Sun/Oracle Java installation on Ubuntu 12.
 
 #. **Android SDK**
 
@@ -83,9 +103,13 @@ You need the following software to be installed in order to develop for Android
 
    Here is Google's `install guide <http://developer.android.com/sdk/installing.html>`_ for the SDK.
 
-   .. note:: If you choose SDK packed into a Windows installer, then you should have 32-bit JRE installed. It is not a prerequisite for Android development, but installer is a x86 application and requires 32-bit Java runtime.
+   .. note:: If you choose SDK packed into a Windows installer, then you should have 32-bit JRE
+             installed. It is not a prerequisite for Android development, but installer is a x86
+             application and requires 32-bit Java runtime.
 
-   .. note:: If you are running x64 version of Ubuntu Linux, then you need ia32 shared libraries for use on amd64 and ia64 systems to be installed. You can install them with the following command:
+   .. note:: If you are running x64 version of Ubuntu Linux, then you need ia32 shared libraries
+             for use on amd64 and ia64 systems to be installed. You can install them with the
+             following command:
 
       .. code-block:: bash
 
@@ -101,51 +125,70 @@ You need the following software to be installed in order to develop for Android
 
    You need the following SDK components to be installed:
 
-   * *Android SDK Tools, revision14* or newer.
+   * *Android SDK Tools, revision 20* or newer.
 
      Older revisions should also work, but they are not recommended.
 
-   * *SDK Platform Android 3.0*, ``API 11`` and *Android 2.3.1*, ``API 9``.
+   * *SDK Platform Android 3.0* (``API 11``).
 
-     The minimal platform supported by OpenCV Java API is **Android 2.2** (``API 8``). This is also the minimum API Level required for the provided samples to run.
+     The minimal platform supported by OpenCV Java API is **Android 2.2** (``API 8``). This is also
+     the minimum API Level required for the provided samples to run.
      See the ``<uses-sdk android:minSdkVersion="8"/>`` tag in their **AndroidManifest.xml** files.
-     But for successful compilation of some samples the **target** platform should be set to Android 3.0 (API 11) or higher. It will not prevent them from running on  Android 2.2.
+     But for successful compilation the **target** platform should be set to Android 3.0 (API 11) or higher. It will not prevent them from running on  Android 2.2.
 
      .. image:: images/android_sdk_and_avd_manager.png
-        :height: 500px
         :alt: Android SDK Manager
         :align: center
 
-     See `Adding Platforms and Packages  <http://developer.android.com/sdk/installing/adding-packages.html>`_ for help with installing/updating SDK components.
+     See `Adding Platforms and Packages <http://developer.android.com/sdk/installing/adding-packages.html>`_
+     for help with installing/updating SDK components.
 
 #. **Eclipse IDE**
 
-   Check the `Android SDK System Requirements <http://developer.android.com/sdk/requirements.html>`_ document for a list of Eclipse versions that are compatible with the Android SDK.
-   For OpenCV 2.4.x we recommend **Eclipse 3.7 (Indigo)** or later versions. They work well for OpenCV under both Windows and Linux.
+   Check the `Android SDK System Requirements <http://developer.android.com/sdk/requirements.html>`_
+   document for a list of Eclipse versions that are compatible with the Android SDK.
+   For OpenCV 2.4.x we recommend **Eclipse 3.7 (Indigo)** or later versions. They work well for
+   OpenCV under both Windows and Linux.
 
    If you have no Eclipse installed, you can get it from the `official site <http://www.eclipse.org/downloads/>`_.
 
 #. **ADT plugin for Eclipse**
 
-   These instructions are copied from `Android Developers site <http://developer.android.com/sdk/installing/installing-adt.html>`_, check it out in case of any ADT-related problem.
+   These instructions are copied from
+   `Android Developers site <http://developer.android.com/sdk/installing/installing-adt.html>`_,
+   check it out in case of any ADT-related problem.
 
-   Assuming that you have Eclipse IDE installed, as described above, follow these steps to download and install the ADT plugin:
+   Assuming that you have Eclipse IDE installed, as described above, follow these steps to download
+   and install the ADT plugin:
 
    #. Start Eclipse, then select :menuselection:`Help --> Install New Software...`
    #. Click :guilabel:`Add` (in the top-right corner).
-   #. In the :guilabel:`Add Repository` dialog that appears, enter "ADT Plugin" for the Name and the following URL for the Location:
+   #. In the :guilabel:`Add Repository` dialog that appears, enter "ADT Plugin" for the Name and the
+      following URL for the Location:
 
       https://dl-ssl.google.com/android/eclipse/
 
    #. Click :guilabel:`OK`
 
-      .. note:: If you have trouble acquiring the plugin, try using "http" in the Location URL, instead of "https" (https is preferred for security reasons).
+      .. note:: If you have trouble acquiring the plugin, try using "http" in the Location URL,
+                instead of "https" (https is preferred for security reasons).
 
-   #. In the :guilabel:`Available Software` dialog, select the checkbox next to :guilabel:`Developer Tools` and click :guilabel:`Next`.
+   #. In the :guilabel:`Available Software` dialog, select the checkbox next to
+      :guilabel:`Developer Tools` and click :guilabel:`Next`.
    #. In the next window, you'll see a list of the tools to be downloaded. Click :guilabel:`Next`.
+
+      .. note:: If you also plan to develop native C++ code with Android NDK don't forget to
+                enable `NDK Plugins` installations as well.
+
+      .. image:: images/eclipse_inst_adt.png
+         :alt: ADT installation
+         :align: center
+
+
    #. Read and accept the license agreements, then click :guilabel:`Finish`.
 
-      .. note:: If you get a security warning saying that the authenticity or validity of the software can't be established, click :guilabel:`OK`.
+      .. note:: If you get a security warning saying that the authenticity or validity of the software
+                can't be established, click :guilabel:`OK`.
 
    #. When the installation completes, restart Eclipse.
 
@@ -158,27 +201,47 @@ You need the following software to be installed in order to develop for Android
 
    To compile C++ code for Android platform you need ``Android Native Development Kit`` (*NDK*).
 
-   You can get the latest version of NDK from the `download page <http://developer.android.com/tools/sdk/ndk/index.html>`_. To install Android NDK just extract the archive to some folder on your computer. Here are `installation instructions <http://developer.android.com/tools/sdk/ndk/index.html#Installing>`_.
+   You can get the latest version of NDK from the
+   `download page <http://developer.android.com/tools/sdk/ndk/index.html>`_.
+   To install Android NDK just extract the archive to some folder on your computer. Here are
+   `installation instructions <http://developer.android.com/tools/sdk/ndk/index.html#Installing>`_.
 
-   .. note:: Before start you can read official Android NDK documentation which is in the Android NDK archive, in the folder :file:`docs/`.
-
-      The main article about using Android NDK build system is in the :file:`ANDROID-MK.html` file.
-
-      Some additional information you can find in the :file:`APPLICATION-MK.html`, :file:`NDK-BUILD.html` files, and :file:`CPU-ARM-NEON.html`, :file:`CPLUSPLUS-SUPPORT.html`, :file:`PREBUILTS.html`.
+   .. note:: Before start you can read official Android NDK documentation which is in the Android
+             NDK archive, in the folder :file:`docs/`.
+             The main article about using Android NDK build system is in the :file:`ANDROID-MK.html` file.
+             Some additional information you can find in the :file:`APPLICATION-MK.html`,
+             :file:`NDK-BUILD.html` files, and :file:`CPU-ARM-NEON.html`, :file:`CPLUSPLUS-SUPPORT.html`,
+             :file:`PREBUILTS.html`.
 
 #. **CDT plugin for Eclipse**
 
-   There are several possible ways to integrate compilation of C++ code by Android NDK into Eclipse compilation process.
-   We recommend the approach based on Eclipse :abbr:`CDT(C/C++ Development Tooling)` Builder.
+   There are several possible ways to integrate compilation of C++ code by Android NDK into Eclipse
+   compilation process. We recommend the approach based on Eclipse
+   :abbr:`CDT(C/C++ Development Tooling)` Builder.
+   Make sure your Eclipse IDE has the :abbr:`CDT(C/C++ Development Tooling)` plugin
+   installed. Menu :guilabel:`Help -> About Eclipse SDK -> Installation Details`.
 
-   .. important:: Make sure your Eclipse IDE has the :abbr:`CDT(C/C++ Development Tooling)` plugin installed. Menu :guilabel:`Help -> About Eclipse SDK` and push :guilabel:`Installation Details` button.
+       .. image:: images/eclipse_about_cdt_0.png
+         :alt: CDT in Eclipse About
+         :align: center
 
-   .. image:: images/eclipse_inst_details.png
-     :alt: Configure builders
+   ..
+
+       .. image:: images/eclipse_about_cdt_1.png
+         :alt: CDT in Eclipse About
+         :align: center
+
+   .. note:: If you're using the latest ADT plugin for Eclipse (version 20 and above), most likely
+             you already have the CDT plugin and don't need to install it.
+
+   .. image:: images/eclipse_about_cdt_1.png
+     :alt: CDT in Eclipse About
      :align: center
 
-   To install the `CDT plugin <http://eclipse.org/cdt/>`_ use menu :guilabel:`Help -> Install New Software...`,
-   then paste the CDT 8.0 repository URL http://download.eclipse.org/tools/cdt/releases/indigo as shown in the picture below and click :guilabel:`Add...`, name it *CDT* and click :guilabel:`OK`.
+   To install the `CDT plugin <http://eclipse.org/cdt/>`_ use menu
+   :guilabel:`Help -> Install New Software...`, then paste the CDT 8.0 repository URL
+   http://download.eclipse.org/tools/cdt/releases/indigo as shown in the picture below and click
+   :guilabel:`Add...`, name it *CDT* and click :guilabel:`OK`.
 
    .. image:: images/eclipse_inst_cdt.png
      :alt: Configure builders
@@ -192,6 +255,7 @@ You need the following software to be installed in order to develop for Android
 
    That's it. Compilation of C++ code is fully integrated into Eclipse building process now.
 
+
 Android application structure
 =============================
 
@@ -213,27 +277,32 @@ Usually source code of an Android application has the following structure:
 
   - :file:`... other files ...`
 
-where:
+Where:
 
 * the :file:`src` folder contains Java code of the application,
 
-* the :file:`res` folder contains resources of the application (images, xml files describing UI layout, etc),
+* the :file:`res` folder contains resources of the application (images, xml files describing UI
+  layout, etc),
 
 * the :file:`libs` folder will contain native libraries after a successful build,
 
-* and the :file:`jni` folder contains C/C++ application source code and NDK's build scripts :file:`Android.mk` and :file:`Application.mk`
-  producing the native libraries,
+* and the :file:`jni` folder contains C/C++ application source code and NDK's build scripts
+  :file:`Android.mk` and :file:`Application.mk` producing the native libraries,
 
-* :file:`AndroidManifest.xml` file presents essential information about application to the Android system
-  (name of the Application, name of main application's package, components of the application, required permissions, etc).
+* :file:`AndroidManifest.xml` file presents essential information about application to the Android
+  system (name of the Application, name of main application's package, components of the
+  application, required permissions, etc).
 
   It can be created using Eclipse wizard or :command:`android` tool from Android SDK.
 
-* :file:`project.properties` is a text file containing information about target Android platform and other build details.
-  This file is generated by Eclipse or can be created with :command:`android` tool included in Android SDK.
+* :file:`project.properties` is a text file containing information about target Android platform
+  and other build details. This file is generated by Eclipse or can be created with
+  :command:`android` tool included in Android SDK.
+
+.. note:: Both :file:`AndroidManifest.xml` and :file:`project.properties` files are required to
+          compile the C++ part of the application, since Android NDK build system relies on them.
+          If any of these files does not exist, compile the Java part of the project before the C++ part.
 
-.. note:: Both files (:file:`AndroidManifest.xml` and :file:`project.properties`) are required to compile the C++ part of the application,
-          since Android NDK build system relies on them. If any of these files does not exist, compile the Java part of the project before the C++ part.
 
 :file:`Android.mk` and :file:`Application.mk` scripts
 ==================================================================
@@ -254,16 +323,22 @@ The script :file:`Android.mk` usually has the following structure:
 
    include $(BUILD_SHARED_LIBRARY)
 
-This is the minimal file :file:`Android.mk`, which builds C++ source code of an Android application. Note that the first two lines and the last line are mandatory for any :file:`Android.mk`.
+This is the minimal file :file:`Android.mk`, which builds C++ source code of an Android application.
+Note that the first two lines and the last line are mandatory for any :file:`Android.mk`.
 
-Usually the file :file:`Application.mk` is optional, but in case of project using OpenCV, when STL and exceptions are used in C++, it also should be created. Example of the file :file:`Application.mk`:
+Usually the file :file:`Application.mk` is optional, but in case of project using OpenCV, when STL
+and exceptions are used in C++, it also should be created. Example of the file :file:`Application.mk`:
 
 .. code-block:: make
    :linenos:
 
    APP_STL := gnustl_static
    APP_CPPFLAGS := -frtti -fexceptions
-   APP_ABI := armeabi-v7a
+   APP_ABI := all
+
+.. note:: We recommend setting ``APP_ABI := all`` for all targets. If you want to specify the 
+          target explicitly, use ``armeabi`` for ARMv5/ARMv6, ``armeabi-v7a`` for ARMv7, ``x86`` 
+          for Intel Atom or ``mips`` for MIPS. 
 
 
 .. _NDK_build_cli:
@@ -285,7 +360,8 @@ Here is the standard way to compile C++ part of an Android application:
 
         <path_where_NDK_is_placed>/ndk-build
 
-   .. note:: On Windows we recommend to use ``ndk-build.cmd`` in standard Windows console (``cmd.exe``) rather than the similar ``bash`` script in ``Cygwin`` shell.
+   .. note:: On Windows we recommend to use ``ndk-build.cmd`` in standard Windows console (``cmd.exe``)
+            rather than the similar ``bash`` script in ``Cygwin`` shell.
 
    .. image:: images/ndk_build.png
       :alt: NDK build
@@ -314,22 +390,22 @@ After that the Java part of the application can be (re)compiled (using either *E
 Building application native part from *Eclipse* (CDT Builder)
 =============================================================
 
-There are several possible ways to integrate compilation of native C++ code by Android NDK into Eclipse build process.
-We recommend the approach based on Eclipse :abbr:`CDT(C/C++ Development Tooling)` Builder.
+There are several possible ways to integrate compilation of native C++ code by Android NDK into
+Eclipse build process. We recommend the approach based on Eclipse
+:abbr:`CDT(C/C++ Development Tooling)` Builder.
 
-.. important:: Make sure your Eclipse IDE has the :abbr:`CDT(C/C++ Development Tooling)` plugin installed. Menu :guilabel:`Help -> About Eclipse SDK -> Installation Details`.
+.. important:: OpenCV for Android package since version 2.4.2 contains sample projects
+               pre-configured CDT Builders. For your own projects follow the steps below.
 
-.. image:: images/eclipse_inst_details.png
-  :alt: Eclipse About
-  :align: center
+#. Define the ``NDKROOT`` environment variable containing the path to Android NDK in your system
+   (e.g. ``"X:\\Apps\\android-ndk-r8"`` or ``"/opt/android-ndk-r8"``).
 
-.. important:: OpenCV for Android package since version 2.4.2 contains sample projects pre-configured CDT Builders. For your own projects follow the steps below.
+   **On Windows** an environment variable can be set via
+   :guilabel:`My Computer -> Properties -> Advanced -> Environment variables` and restarting Eclipse.
+   On Windows 7 it's also possible to use `setx <http://ss64.com/nt/setx.html>`_ command in a console session.
 
-#. Define the ``NDKROOT`` environment variable containing the path to Android NDK in your system (e.g. ``"X:\\Apps\\android-ndk-r8"`` or ``"/opt/android-ndk-r8"``).
-    **On Windows** an environment variable can be set via :guilabel:`My Computer -> Properties -> Advanced -> Environment variables` and restarting Eclipse.
-    On Windows 7 it's also possible to use `setx <http://ss64.com/nt/setx.html>`_ command in a console session.
-
-    **On Linux** and **MacOS** an environment variable can be set via appending a ``"export VAR_NAME=VAR_VALUE"`` line to the :file:`"~/.bashrc"` file and logging off and then on.
+   **On Linux** and **MacOS** an environment variable can be set via appending a
+   ``"export VAR_NAME=VAR_VALUE"`` line to the :file:`"~/.bashrc"` file and logging off and then on.
 
 #. Open Eclipse and load the Android app project to configure.
 
@@ -345,13 +421,15 @@ We recommend the approach based on Eclipse :abbr:`CDT(C/C++ Development Tooling)
       :alt: Configure CDT
       :align: center
 
-#. Select the project(s) to convert. Specify "Project type" = ``Makefile project``, "Toolchains" = ``Other Toolchain``.
+#. Select the project(s) to convert. Specify "Project type" = ``Makefile project``,
+   "Toolchains" = ``Other Toolchain``.
 
      .. image:: images/eclipse_cdt_cfg3.png
         :alt: Configure CDT
         :align: center
 
-#. Open :guilabel:`Project Properties -> C/C++ Build`, unckeck ``Use default build command``, replace "Build command" text from ``"make"`` to
+#. Open :guilabel:`Project Properties -> C/C++ Build`, uncheck ``Use default build command``,
+   replace "Build command" text from ``"make"`` to
 
    ``"${NDKROOT}/ndk-build.cmd"`` on Windows,
 
@@ -373,13 +451,15 @@ We recommend the approach based on Eclipse :abbr:`CDT(C/C++ Development Tooling)
       :alt: Configure CDT
       :align: center
 
-#. If you open your C++ source file in Eclipse editor, you'll see syntax error notifications. They are not real errors, but additional CDT configuring is required.
+#. If you open your C++ source file in Eclipse editor, you'll see syntax error notifications.
+   They are not real errors, but additional CDT configuring is required.
 
    .. image:: images/eclipse_cdt_cfg7.png
       :alt: Configure CDT
       :align: center
 
-#. Open :guilabel:`Project Properties -> C/C++ General -> Paths and Symbols` and add the following **Include** paths for **C++**:
+#. Open :guilabel:`Project Properties -> C/C++ General -> Paths and Symbols` and add the following
+   **Include** paths for **C++**:
 
    ::
 
@@ -396,7 +476,8 @@ We recommend the approach based on Eclipse :abbr:`CDT(C/C++ Development Tooling)
       :alt: Configure CDT
       :align: center
 
-   .. note:: The latest Android NDK **r8b** uses different STL headers path. So if you use this NDK release add the following **Include** paths list instead:
+   .. note:: The latest Android NDK **r8b** uses different STL headers path. So if you use this NDK
+             release add the following **Include** paths list instead:
 
    ::
 
@@ -408,46 +489,62 @@ We recommend the approach based on Eclipse :abbr:`CDT(C/C++ Development Tooling)
 
 Debugging and Testing
 =====================
-In this section we will give you some easy-to-follow instructions on how to set up an emulator or hardware device for testing and debugging an Android project.
+In this section we will give you some easy-to-follow instructions on how to set up an emulator or
+hardware device for testing and debugging an Android project.
 
 AVD
 ---
-AVD (*Android Virtual Device*) is not probably the most convenient way to test an OpenCV-dependent application, but sure the most uncomplicated one to configure.
+AVD (*Android Virtual Device*) is not probably the most convenient way to test an OpenCV-dependent
+application, but sure the most uncomplicated one to configure.
 
-#. Assuming you already have *Android SDK* and *Eclipse IDE* installed, in Eclipse go :guilabel:`Window -> AVD Manager`.
+#. Assuming you already have *Android SDK* and *Eclipse IDE* installed, in Eclipse go
+   :guilabel:`Window -> AVD Manager`.
 
-   ..     **TBD:** how to start AVD Manager without Eclipse...
+   .. TODO: how to start AVD Manager without Eclipse...
 
 #. Press the :guilabel:`New` button in :guilabel:`AVD Manager` window.
-#. :guilabel:`Create new Android Virtual Device` window will let you select some properties for your new device, like target API level, size of SD-card and other.
+#. :guilabel:`Create new Android Virtual Device` window will let you select some properties for your
+   new device, like target API level, size of SD-card and other.
 
    .. image:: images/AVD_create.png
       :alt: Configure builders
       :align: center
 
 #. When you click the :guilabel:`Create AVD` button, your new AVD will be availible in :guilabel:`AVD Manager`.
-#. Press :guilabel:`Start` to launch the device. Be aware that any AVD (a.k.a. Emulator) is usually much slower than a hardware Android device, so it may take up to several minutes to start.
-#. Go :guilabel:`Run -> Run/Debug`  in Eclipse IDE to run your application in regular or debugging mode. :guilabel:`Device Chooser` will let you choose among the running devices or to start a new one.
+#. Press :guilabel:`Start` to launch the device. Be aware that any AVD (a.k.a. Emulator) is usually
+   much slower than a hardware Android device, so it may take up to several minutes to start.
+#. Go :guilabel:`Run -> Run/Debug`  in Eclipse IDE to run your application in regular or debugging
+   mode. :guilabel:`Device Chooser` will let you choose among the running devices or to start a new one.
 
 Hardware Device
 ---------------
-If you have an Android device, you can use it to test and debug your applications. This way is more authentic, though a little bit harder to set up. You need to make some actions for Windows and Linux operating systems to be able to work with Android devices. No extra actions are required for Mac OS. See detailed information on configuring hardware devices in subsections below.
+If you have an Android device, you can use it to test and debug your applications. This way is more
+authentic, though a little bit harder to set up. You need to make some actions for Windows and Linux
+operating systems to be able to work with Android devices. No extra actions are required for Mac OS.
+See detailed information on configuring hardware devices in subsections below.
 
-You may also consult the official `Android Developers site instructions <http://developer.android.com/tools/device.html>`_ for more information.
+You may also consult the official
+`Android Developers site instructions <http://developer.android.com/tools/device.html>`_
+for more information.
 
 Windows host computer
 ^^^^^^^^^^^^^^^^^^^^^
 
 #. Enable USB debugging on the Android device (via :guilabel:`Settings` menu).
 #. Attach the Android device to your PC with a USB cable.
-#. Go to :guilabel:`Start Menu` and **right-click** on :guilabel:`Computer`. Select :guilabel:`Manage` in the context menu. You may be asked for Administrative permissions.
-#. Select :guilabel:`Device Manager` in the left pane and find an unknown device in the list. You may try unplugging it and then plugging back in order to check whether it's your exact equipment appears in the list.
+#. Go to :guilabel:`Start Menu` and **right-click** on :guilabel:`Computer`.
+   Select :guilabel:`Manage` in the context menu. You may be asked for Administrative permissions.
+#. Select :guilabel:`Device Manager` in the left pane and find an unknown device in the list.
+   You may try unplugging it and then plugging back in order to check whether it's your exact
+   equipment appears in the list.
 
    .. image:: images/usb_device_connect_01.png
       :alt: Unknown device
       :align: center
 
-#. Try your luck installing `Google USB drivers` without any modifications: **right-click** on the unknown device, select :guilabel:`Properties` menu item --> :guilabel:`Details` tab --> :guilabel:`Update Driver` button.
+#. Try your luck installing `Google USB drivers` without any modifications: **right-click** on the
+   unknown device, select :guilabel:`Properties` menu item --> :guilabel:`Details` tab -->
+   :guilabel:`Update Driver` button.
 
    .. image:: images/usb_device_connect_05.png
       :alt: Device properties
@@ -465,13 +562,15 @@ Windows host computer
       :alt: Browse for driver
       :align: center
 
-#. If you get the prompt to install unverified drivers and report about success - you've finished with USB driver installation.
+#. If you get the prompt to install unverified drivers and report about success - you've finished
+   with USB driver installation.
 
    .. image:: images/usb_device_connect_08.png
       :alt: Install prompt
       :align: center
 
    ` `
+    .. FIXME: All such places should be replaced with something else! This is a bad separator.
 
    .. image:: images/usb_device_connect_09.png
       :alt: Installed OK
@@ -483,13 +582,15 @@ Windows host computer
       :alt: No driver
       :align: center
 
-#. Again **right-click** on the unknown device, select :guilabel:`Properties --> Details --> Hardware Ids` and copy the line like ``USB\VID_XXXX&PID_XXXX&MI_XX``.
+#. Again **right-click** on the unknown device, select :guilabel:`Properties --> Details --> Hardware Ids`
+   and copy the line like ``USB\VID_XXXX&PID_XXXX&MI_XX``.
 
    .. image:: images/usb_device_connect_02.png
       :alt: Device properties details
       :align: center
 
-#. Now open file :file:`<Android SDK folder>/extras/google/usb_driver/android_winusb.inf`. Select either ``Google.NTx86`` or ``Google.NTamd64`` section depending on your host system architecture.
+#. Now open file :file:`<Android SDK folder>/extras/google/usb_driver/android_winusb.inf`. Select
+   either ``Google.NTx86`` or ``Google.NTamd64`` section depending on your host system architecture.
 
    .. image:: images/usb_device_connect_03.png
       :alt: "android_winusb.inf"
@@ -543,17 +644,23 @@ Windows host computer
       :alt: "adb devices"
       :align: center
 
-#. Now, in Eclipse go :guilabel:`Run -> Run/Debug` to run your application in regular or debugging mode. :guilabel:`Device Chooser` will let you choose among the devices.
+#. Now, in Eclipse go :guilabel:`Run -> Run/Debug` to run your application in regular or debugging
+   mode. :guilabel:`Device Chooser` will let you choose among the devices.
 
 Linux host computer
 ^^^^^^^^^^^^^^^^^^^
-By default Linux doesn't recognize Android devices, but it's easy to fix this issue. On Ubuntu Linux you have to create a new **/etc/udev/rules.d/51-android.rules** configuration file that contains information about your Android device. You may find some Vendor ID's `here <http://developer.android.com/tools/device.html#VendorIds>`_ or execute :command:`lsusb` command to view VendorID of plugged Android device. Here is an example of such file for LG device:
+By default Linux doesn't recognize Android devices, but it's easy to fix this issue. On Ubuntu Linux
+you have to create a new **/etc/udev/rules.d/51-android.rules** configuration file that contains
+information about your Android device. You may find some Vendor ID's
+`here <http://developer.android.com/tools/device.html#VendorIds>`_ or execute :command:`lsusb`
+command to view VendorID of plugged Android device. Here is an example of such file for LG device:
 
 .. code-block:: guess
 
    SUBSYSTEM=="usb", ATTR{idVendor}=="1004",  MODE="0666", GROUP="plugdev"
 
-Then restart your adb server (even better to restart the system), plug in your Android device and execute :command:`adb devices` command. You will see the list of attached devices:
+Then restart your adb server (even better to restart the system), plug in your Android device and
+execute :command:`adb devices` command. You will see the list of attached devices:
 
 .. image:: images/usb_device_connect_ubuntu.png
    :alt: List of attached devices
@@ -566,4 +673,5 @@ No actions are required, just connect your device via USB and run ``adb devices`
 What's next
 ===========
 
-Now, when you have your development environment set up and configured, you may want to proceed to installing OpenCV4Android SDK. You can learn how to do that in a separate :ref:`O4A_SDK` tutorial.
+Now, when you have your development environment set up and configured, you may want to proceed to
+installing OpenCV4Android SDK. You can learn how to do that in a separate :ref:`O4A_SDK` tutorial.

doc/tutorials/introduction/how_to_write_a_tutorial/how_to_write_a_tutorial.rst

@@ -1,36 +1,56 @@
 .. _howToWriteTutorial:
+
 How to write a tutorial for OpenCV?
 ***********************************
+
 Okay, so assume you have just finished a project of yours implementing something based on OpenCV and you want to present/share it with the community. Luckily, OpenCV is an *open source project*. This means that in theory anyone has access to the full source code and may extend it. While making a robust and practical library (like OpenCV) is great, the success of a library also depends on how user friendly it is. To improve on this aspect, the OpenCV team has already been listening to user feedback from its :opencv_group:`Yahoo user group <>` and by making samples you can find in the source directories sample folder. The addition of the tutorials (in both online and PDF format) is an extension of these efforts.
+
 Goal
 ====
 .. _reST: http://docutils.sourceforge.net/rst.html
+
 .. |reST| replace:: reStructuredText
+
 .. |Sphinx| replace:: Sphinx
+
 .. _Sphinx: http://sphinx.pocoo.org/
+
 The tutorials are just as an important part of the library as  the implementation of those crafty data structures and algorithms you can find in OpenCV. Therefore, the source codes for the tutorials are part of the library. And yes, I meant source codes. The reason for this formulation is that the tutorials are written by using the |Sphinx|_ documentation generation system. This is based on the popular python documentation system called |reST|_ (reST). ReStructuredText is a really neat language that by using a few simple conventions (indentation, directives) and emulating old school e-mail writing techniques (text only) tries to offer a simple way to create and edit documents. Sphinx extends this with some new features and creates the resulting document in both HTML (for web) and PDF (for offline usage) format.
+
 Usually, an OpenCV tutorial has the following parts:
-1. A source code demonstration of an OpenCV feature:
-   a. One or more CPP, Python, Java or other type of files depending for what OpenCV offers support and for what language you make the tutorial.
-   #. Occasionaly, input resource files required for running your tutorials application.
-#. A table of content entry (so people may easily find the tutorial):
-   a. Adding your stuff to the tutorials table of content (**reST** file).
-   #. Add an image file near the TOC entry.
-#. The content of the tutorial itself:
-   a. The **reST** text of the tutorial
-   #. Images following the idea that "*A picture is worth a thousand words*".
-   #. For more complex demonstrations you may create a video.
+
+  1. A source code demonstration of an OpenCV feature:
+
+    a. One or more CPP, Python, Java or other type of files depending for what OpenCV offers support and for what language you make the tutorial.
+    #. Occasionaly, input resource files required for running your tutorials application.
+
+  2. A table of content entry (so people may easily find the tutorial):
+
+    a. Adding your stuff to the tutorials table of content (**reST** file).
+    #. Add an image file near the TOC entry.
+
+  3. The content of the tutorial itself:
+
+    a. The **reST** text of the tutorial
+    #. Images following the idea that "*A picture is worth a thousand words*".
+    #. For more complex demonstrations you may create a video.
+
 As you can see you will need at least some basic knowledge of the *reST* system in order to complete the task at hand with success. However, don't worry *reST* (and *Sphinx*) was made with simplicity in mind. It is easy to grasp its basics. I found that the `OpenAlea documentations introduction on this subject <http://openalea.gforge.inria.fr/doc/openalea/doc/_build/html/source/tutorial/rest_syntax.html>`_ (or the `Thomas Cokelaer one <http://thomas-cokelaer.info/tutorials/sphinx/rest_syntax.html>`_ ) should enough for this. If for some directive or feature you need a more in-depth description look it up in the official |reST|_ help files or at the |Sphinx|_ documentation.
 In our world achieving some tasks is possible in multiple ways. However, some of the roads to take may have obvious or hidden advantages over others. Then again, in some other cases it may come down to just simple user preference. Here, I'll present how I decided to write the tutorials, based on my personal experience. If for some of them you know a better solution and you can back it up feel free to use that. I've nothing against it, as long as it gets the job done in an elegant fashion.
 Now the best would be if you could make the integration yourself. For this you need first to have the source code. I recommend following the guides for your operating system on acquiring OpenCV sources. For Linux users look :ref:`here <Linux-Installation>` and for :ref:`Windows here <Windows_Installation>`. You must also install python and sphinx with its dependencies in order to be able to build the documentation.
 Once you have downloaded the repository to your hard drive you can take a look in the OpenCV directory to make sure you have both the samples and doc folder present. Anyone may download the trunk source files from  :file:`git://code.opencv.org/opencv.git` . Nevertheless, not everyone has upload (commit/submit) rights. This is to protect the integrity of the library. If you plan doing more than one tutorial, and would like to have an account with commit user rights you should first register an account at http://code.opencv.org/ and then contact dr. Gary Bradski at -delete-bradski@-delete-willowgarage.com. Otherwise, you can just send the resulting files to us via the :opencv_group:`Yahoo user group <>` or to me at -delete-bernat@-delete-primeranks.net and I'll add it. If you have questions, suggestions or constructive critics I will gladly listen to them. If you send it to the OpenCV group please tag its subject with a **[Tutorial]** entry.
+
 Format the Source Code
 ======================
-Before I start this let it be clear: the main goal is to have a working sample code. However, for your tutorial to be of a top notch quality you should follow a few guide lines I am going to present here.
-In case you have an application by using the older interface (with *IplImage*, *CVMat*, *cvLoadImage* and such) consider migrating it to the new C++ interface. The tutorials are intended to be an up to date help for our users. And as of OpenCV 2 the OpenCV emphasis on using the less error prone and clearer C++ interface. Therefore, if possible please convert your code to the C++ interface. For this it may help to read the :ref:`InteroperabilityWithOpenCV1` tutorial. However, once you have an OpenCV 2 working code, then you should make your source code snippet as easy to read as possible. Here're a couple of advices for this:
+
+Before I start this let it be clear: the main goal is to have a working sample code. However, for your tutorial to be of a top notch quality you should follow a few guide lines I am going to present here. In case you have an application by using the older interface (with *IplImage*, *CVMat*, *cvLoadImage* and such) consider migrating it to the new C++ interface. The tutorials are intended to be an up to date help for our users. And as of OpenCV 2 the OpenCV emphasis on using the less error prone and clearer C++ interface. Therefore, if possible please convert your code to the C++ interface. For this it may help to read the :ref:`InteroperabilityWithOpenCV1` tutorial. However, once you have an OpenCV 2 working code, then you should make your source code snippet as easy to read as possible. Here're a couple of advices for this:
+
 .. container:: enumeratevisibleitemswithsquare
+
    + Add a standard output with the description of what your program does. Keep it short and yet, descriptive. This output is at the start of the program. In my example files this usually takes the form of a *help* function containing the output. This way both the source file viewer and application runner can see what all is about in your sample. Here's an instance of this:
+
      .. code-block:: cpp
+
         void help()
         {
         cout
@@ -48,29 +68,46 @@ In case you have an application by using the older interface (with *IplImage*, *
         help();
         // here comes the actual source code
         }
+
      Additionally, finalize the description with a short usage guide. This way the user will know how to call your programs, what leads us to the next point.
+
    + Prefer command line argument controlling instead of hard coded one. If your program has some variables that may be changed use command line arguments for this. The tutorials, can be a simple try-out ground for the user. If you offer command line controlling for the input image (for example), then you offer the possibility for the user to try it out with his/her own images, without the need to mess in the source code. In the upper example you can see that the input image, channel and codec selection may all be changed from the command line. Just compile the program and run it with your own input arguments.
+
    + Be as verbose as possible. There is no shame in filling the source code with comments. This way the more advanced user may figure out what's happening right from the sample code. This advice goes for the output console too. Specify to the user what's happening. Never leave the user hanging there and thinking on: "Is this program now crashing or just doing some computationally intensive task?." So, if you do a training task that may take some time, make sure you print out a message about this before starting and after finishing it.
+
    + Throw out unnecessary stuff from your source code. This is a warning to not take the previous point too seriously. Balance is the key. If it's something that can be done in a fewer lines or simpler than that's the way you should do it. Nevertheless, if for some reason you have such sections notify the user why you have chosen to do so. Keep the amount of information as low as possible, while still getting the job done in an elegant way.
+
    + Put your sample file into the :file:`opencv/samples/cpp/tutorial_code/sectionName` folder. If you write a tutorial for other languages than cpp, then change that part of the path. Before completing this you need to decide that to what section (module) does your tutorial goes. Think about on what module relies most heavily your code and that is the one to use. If the answer to this question is more than one modules then the *general* section is the one to use. For finding the *opencv* directory open up your file system and navigate where you downloaded our repository.
+
    + If the input resources are hard to acquire for the end user consider adding a few of them to the :file:`opencv/samples/cpp/tutorial_code/images`. Make sure that who reads your code can try it out!
+
 Add the TOC entry
 =================
+
 For this you will need to know some |reST|_. There is no going around this. |reST|_ files have **rst** extensions. However, these are simple text files. Use any text editor you like. Finding a text editor that offers syntax highlighting for |reST|_ was quite a challenge at the time of writing this tutorial. In my experience, `Intype <http://intype.info/>`_ is a solid option on Windows, although there is still place for improvement.
+
 Adding your source code to a table of content is important for multiple reasons. First and foremost this will allow for the user base to find your tutorial from our websites tutorial table of content. Secondly, if you omit this *Sphinx* will throw a warning that your tutorial file isn't part of any TOC tree entry. And there is nothing more than the developer team hates than an ever increasing warning/error list for their builds. *Sphinx* also uses this to build up the previous-back-up buttons on the website. Finally, omitting this step will lead to that your tutorial will **not** be added to the PDF version of the tutorials.
+
 Navigate to the :file:`opencv/doc/tutorials/section/table_of_content_section` folder (where the section is the module to which you're adding the tutorial). Open the *table_of_content_section* file. Now this may have two forms. If no prior tutorials are present in this section that there is a template message about this and has the following form:
+
 .. code-block:: rst
+
   .. _Table-Of-Content-Section:
+
    Section title
    -----------------------------------------------------------
    Description about the section.
    .. include:: ../../definitions/noContent.rst
    .. raw:: latex
       \pagebreak
+
 The first line is a reference to the section title in the reST system. The section title will be a link and you may refer to it via the ``:ref:`` directive. The *include* directive imports the template text from the definitions directories *noContent.rst* file. *Sphinx* does not creates the PDF from scratch. It does this by first creating a latex file. Then creates the PDF from the latex file. With the *raw* directive you can directly add to this output commands. Its unique argument is for what kind of output to add the content of the directive. For the PDFs it may happen that multiple sections will overlap on a single page. To avoid this at the end of the TOC we add a *pagebreak* latex command, that hints to the LATEX system that the next line should be on a new page.
 If you have one of this, try to transform it to the following form:
+
 .. include:: ../../definitions/tocDefinitions.rst
+
 .. code-block:: rst
+
    .. _Table-Of-Content-Section:
    Section title
    -----------------------------------------------------------
@@ -88,16 +125,25 @@ If you have one of this, try to transform it to the following form:
                       :height: 90pt
                       :width:  90pt
    .. raw:: latex
+
       \pagebreak
+
    .. toctree::
+
       :hidden:
       ../mat - the basic image container/mat - the basic image container
+
 If this is already present just add a new section of the content between the include and the raw directives (excluding those lines). Here you'll see a new include directive. This should be present only once in a TOC tree and the reST file contains the definitions of all the authors contributing to the OpenCV tutorials. We are a multicultural community and some of our name may contain some funky characters. However, reST **only supports** ANSI characters. Luckily we can specify Unicode characters with the *unicode* directive. Doing this for all of your tutorials is a troublesome procedure. Therefore, the tocDefinitions file contains the definition of your author name. Add it here once and afterwards just use the replace construction. For example here's the definition for my name:
+
 .. code-block:: rst
+
    .. |Author_BernatG| unicode:: Bern U+00E1 t U+0020 G U+00E1 bor
+
 The ``|Author_BernatG|`` is the text definitions alias. I can use later this to add the definition, like I've done in the TOCs *Author* part. After the ``::`` and a space you start the definition. If you want to add an UNICODE character (non-ASCI) leave an empty space and specify it in the format U+(UNICODE code). To find the UNICODE code of a character I recommend using the `FileFormat <http://www.fileformat.info>`_ websites service. Spaces are trimmed from the definition, therefore we add a space by its UNICODE character (U+0020).
 Until the *raw* directive what you can see is a TOC tree entry. Here's how a TOC entry will look like:
-+
+
+.. code-block:: rst
+
   .. tabularcolumns:: m{100pt} m{300pt}
   .. cssclass:: toctableopencv
   =============== ======================================================
@@ -109,32 +155,45 @@ Until the *raw* directive what you can see is a TOC tree entry. Here's how a TOC
   .. |MatBasicIma| image:: images/matTheBasicImageStructure.jpg
                    :height: 90pt
                    :width:  90pt
+
 As you can see we have an image to the left and a description box to the right. To create two boxes we use a table with two columns and a single row. In the left column is the image and in the right one the description. However, the image directive is way too long to fit in a column. Therefore, we need to use the substitution definition system. We add this definition after the TOC tree. All images for the TOC tree are to be put in the images folder near its |reST|_ file. We use the point measurement system because we are also creating PDFs. PDFs are printable documents, where there is no such thing that pixels (px), just points (pt). And while generally space is no problem for web pages (we have monitors with **huge** resolutions) the size of the paper (A4 or letter) is constant and will be for a long time in the future. Therefore, size constrains come in play more like for the PDF, than the generated HTML code.
 Now your images should be as small as possible, while still offering the intended information for the user. Remember that the tutorial will become part of the OpenCV source code. If you add large images (that manifest in form of large image size) it will just increase the size of the repository pointlessly. If someone wants to download it later, its download time will be that much longer. Not to mention the larger PDF size for the tutorials and the longer load time for the web pages. In terms of pixels a TOC image should not be larger than 120 X 120 pixels. Resize your images if they are larger!
-.. note::
-   If you add a larger image and specify a smaller image size, *Sphinx* will not resize that. At build time will add the full size image and the resize will be done by your browser after the image is loaded. A 120 X 120 image is somewhere below 10KB. If you add a 110KB image, you have just pointlessly added a 100KB extra data to transfer over the internet for every user!
+
+.. note:: If you add a larger image and specify a smaller image size, *Sphinx* will not resize that. At build time will add the full size image and the resize will be done by your browser after the image is loaded. A 120 X 120 image is somewhere below 10KB. If you add a 110KB image, you have just pointlessly added a 100KB extra data to transfer over the internet for every user!
+
 Generally speaking you shouldn't need to specify your images size (excluding the TOC entries). If no such is found *Sphinx* will use the size of the image itself (so no resize occurs). Then again if for some reason you decide to specify a size that should be the **width** of the image rather than its height. The reason for this again goes back to the PDFs. On a PDF page the height is larger than the width. In the PDF the images will not be resized. If you specify a size that does not fit in the page, then what does not fits in **will be cut off**. When creating your images for your tutorial you should try to keep the image widths below 500 pixels, and calculate with around 400 point page width when specifying image widths.
-The image format depends on the content of the image. If you have some complex scene (many random like colors) then use *jpg*. Otherwise, prefer using *png*. They are even some tools out there that optimize the size of *PNG* images, such as `PNGGauntlet <http://pnggauntlet.com/>`_. Use them to make your images as small as possible in size.
-Now on the right side column of the table we add the information about the tutorial:
+
+The image format depends on the content of the image. If you have some complex scene (many random like colors) then use *jpg*. Otherwise, prefer using *png*. They are even some tools out there that optimize the size of *PNG* images, such as `PNGGauntlet <http://pnggauntlet.com/>`_. Use them to make your images as small as possible in size. Now on the right side column of the table we add the information about the tutorial:
+
 .. container:: enumeratevisibleitemswithsquare
+
    + In the first line it is the title of the tutorial. However, there is no need to specify it explicitly. We use the reference system. We'll start up our tutorial with a reference specification, just like in case of this TOC entry with its  `` .. _Table-Of-Content-Section:`` . If after this you have a title (pointed out by the following line of -), then Sphinx will replace the ``:ref:`Table-Of-Content-Section``` directive with the tile of the section in reference form (creates a link in web page). Here's how the definition looks in my case:
+
      .. code-block:: rst
+
         .. _matTheBasicImageContainer:
            Mat - The Basic Image Container
            *******************************
+
      Note, that according to the |reST|_ rules the * should be as long as your title.
    + Compatibility. What version of OpenCV is required to run your sample code.
    + Author. Use the substitution markup of |reST|_.
    + A short sentence describing the essence of your tutorial.
+
 Now before each TOC entry you need to add the three lines of:
+
 .. code-block:: cpp
+
    +
      .. tabularcolumns:: m{100pt} m{300pt}
      .. cssclass:: toctableopencv
+
 The plus sign (+) is to enumerate tutorials by using bullet points. So for every TOC entry we have a corresponding bullet point represented by the +. Sphinx is highly indenting sensitive. Indentation is used to express from which point until to which point does a construction last. Un-indentation means end of that construction. So to keep all the bullet points to the same group the following TOC entries (until the next +) should be indented by two spaces.
 Here, I should also mention that **always** prefer using spaces instead of tabs. Working with only spaces makes possible that if we both use monotype fonts we will see the same thing. Tab size is text editor dependent and as should be avoided. *Sphinx* translates all tabs into 8 spaces before interpreting it.
 It turns out that the automatic formatting of both the HTML and PDF(LATEX) system messes up our tables. Therefore, we need to help them out a little. For the PDF generation we add the ``.. tabularcolumns:: m{100pt} m{300pt}`` directive. This means that the first column should be 100 points wide and middle aligned. For the HTML look we simply name the following table of a *toctableopencv* class type. Then, we can modify the look of the table by modifying the CSS of our web page. The CSS definitions go into the :file:`opencv/doc/_themes/blue/static/default.css_t` file.
+
 .. code-block:: css
+
    .toctableopencv
    {
     width: 100% ;
@@ -150,91 +209,136 @@ It turns out that the automatic formatting of both the HTML and PDF(LATEX) syste
    {
     width: 100% !important;
    }
+
 However, you should not need to modify this. Just add these three lines (plus keep the two space indentation) for all TOC entries you add. At the end of the TOC file you'll find:
+
 .. code-block:: rst
+
    .. raw:: latex
       \pagebreak
    .. toctree::
       :hidden:
       ../mat - the basic image container/mat - the basic image container
+
 The page break entry comes for separating sections and should be only one in a TOC tree |reST|_ file. Finally, at the end of the TOC tree we need to add our tutorial to the *Sphinx* TOC tree system. *Sphinx* will generate from this the previous-next-up information for the HTML file and add items to the PDF according to the order here. By default this TOC tree directive generates a simple table of contents. However, we already created a fancy looking one so we no longer need this basic one. Therefore, we add the *hidden* option to do not show it.
 The path is of a relative type. We step back in the file system and then go into the :file:`mat - the basic image container` directory for the :file:`mat - the basic image container.rst` file. Putting out the *rst* extension for the file is optional.
+
 Write the tutorial
 ==================
+
 Create a folder with the name of your tutorial. Preferably, use small letters only. Then create a text file in this folder with *rst* extension and the same name. If you have images for the tutorial create an :file:`images` folder and add your images there. When creating your images follow the guidelines described in the previous part!
 Now here's our recommendation for the structure of the tutorial (although, remember that this is not carved in the stone; if you have a better idea, use it!):
+
 .. container:: enumeratevisibleitemswithsquare
+
    + Create the reference point and the title.
+
      .. code-block:: rst
+
         .. _matTheBasicImageContainer:
         Mat - The Basic Image Container
         *******************************
+
      You start the tutorial by specifying a reference point by the ``.. _matTheBasicImageContainer:`` and then its title. The name of the reference point should be a unique one over the whole documentation. Therefore, do not use general names like *tutorial1*. Use the * character to underline the title for its full width. The subtitles of the tutorial should be underlined with = charachter.
    + Goals. You start your tutorial by specifying what you will present. You can also enumerate the sub jobs to be done. For this you can use a bullet point construction. There is a single configuration file for both the reference manual and the tutorial documentation. In the reference manuals at the argument enumeration we do not want any kind of bullet point style enumeration. Therefore, by default all the bullet points at this level are set to do not show the dot before the entries in the HTML. You can override this by putting the bullet point in a container. I've defined a square type bullet point view under the name *enumeratevisibleitemswithsquare*. The CSS style definition for this is again in the  :file:`opencv\doc\_themes\blue\static\default.css_t` file. Here's a quick example of using it:
+
      .. code-block:: rst
+
         .. container:: enumeratevisibleitemswithsquare
            + Create the reference point and the title.
            + Second entry
            + Third entry
+
      Note that you need the keep the indentation of the container directive. Directive indentations are always three (3) spaces. Here you may even give usage tips for your sample code.
    + Source code. Present your samples code to the user. It's a good idea to offer a quick download link for the HTML page by using the *download* directive and pointing out where the user may find your source code in the file system by using the *file* directive:
+
      .. code-block:: rst
+
         Text :file:`samples/cpp/tutorial_code/highgui/video-write/` folder of the OpenCV source library
         or :download:`text to appear in the webpage
         <../../../../samples/cpp/tutorial_code/HighGUI/video-write/video-write.cpp>`.
+
      For the download link the path is a relative one, hence the multiple back stepping operations (..). Then you can add the source code either by using the *code block* directive or the *literal include* one. In case of the code block you will need to actually add all the source code text into your |reST|_ text and also apply the required indentation:
+
      .. code-block:: rst
+
         .. code-block:: cpp
            int i = 0;
            l = ++j;
+
      The only argument of the directive is the language used (here CPP). Then you add the source code into its content (meaning one empty line after the directive) by keeping the indentation of the directive (3 spaces). With the *literal include* directive you do not need to add the source code of the sample. You just specify the sample and *Sphinx* will load it for you, during build time. Here's an example usage:
+
      .. code-block:: rst
+
         .. literalinclude:: ../../../../samples/cpp/tutorial_code/HighGUI/video-write/video-write.cpp
            :language: cpp
            :linenos:
            :tab-width: 4
            :lines: 1-8, 21-22, 24-
+
      After the directive you specify a relative path to the file from what to import. It has four options: the language to use, if you add the ``:linenos:`` the line numbers will be shown, you can specify the tab size with the ``:tab-width:`` and you do not need to load the whole file, you can show just the important lines. Use the *lines* option to do not show redundant information (such as the *help* function). Here basically you specify ranges, if the second range line number is missing than that means that until the end of the file. The ranges specified here do no need to be in an ascending order, you may even reorganize the structure of how you want to show your sample inside the tutorial.
    + The tutorial. Well here goes the explanation for why and what have you used. Try to be short, clear, concise and yet a thorough one. There's no magic formula. Look into a few already made tutorials and start out from there. Try to mix sample OpenCV code with your explanations. If with words is hard to describe something do not hesitate to add in a reasonable size image, to overcome this issue.
      When you present OpenCV functionality it's a good idea to give a link to the used OpenCV data structure or function. Because the OpenCV tutorials and reference manual are in separate PDF files it is not possible to make this link work for the PDF format. Therefore, we use here only web page links to the **opencv.itseez.com** website. The OpenCV functions and data structures may be used for multiple tasks. Nevertheless, we want to avoid that every users creates its own reference to a commonly used function. So for this we use the global link collection of *Sphinx*. This is defined in the file:`opencv/doc/conf.py` configuration file. Open it and go all the way down to the last entry:
+
      .. code-block:: py
+
        # ---- External links for tutorials -----------------
        extlinks = {
-           'huivideo' : ('http://opencv.itseez.com/modules/highgui/doc/reading_and_writing_images_and_video.html#%s', None)
+           'hgvideo' : ('http://opencv.itseez.com/modules/highgui/doc/reading_and_writing_images_and_video.html#%s', None)
            }
-     In short here we defined a new **huivideo** directive that refers to an external webpage link. Its usage is:
+
+     In short here we defined a new **hgvideo** directive that refers to an external webpage link. Its usage is:
+
      .. code-block:: rst
-       A sample function of the highgui modules image write and read page is the :huivideo:`imread() function <imread>`.
-     Which turns to: A sample function of the highgui modules image write and read page is the :huivideo:`imread() function <imread>`. The argument you give between the <> will be put in place of the ``%s`` in the upper definition, and as the link will anchor to the correct function. To find out the anchor of a given function just open up a web page, search for the function and click on it. In the address bar it should appear like: ``http://opencv.itseez.com/modules/highgui/doc/reading_and_writing_images_and_video.html#imread`` .  Look here for the name of the directives for each page of the OpenCV reference manual. If none present for one of them feel free to add one for it.
+
+       A sample function of the highgui modules image write and read page is the :hgvideo:`imread() function <imread>`.
+
+     Which turns to: A sample function of the highgui modules image write and read page is the :hgvideo:`imread() function <imread>`. The argument you give between the <> will be put in place of the ``%s`` in the upper definition, and as the link will anchor to the correct function. To find out the anchor of a given function just open up a web page, search for the function and click on it. In the address bar it should appear like: ``http://opencv.itseez.com/modules/highgui/doc/reading_and_writing_images_and_video.html#imread`` .  Look here for the name of the directives for each page of the OpenCV reference manual. If none present for one of them feel free to add one for it.
      For formulas you can add LATEX code that will translate in the web pages into images. You do this by using the *math* directive. A usage tip:
+
      .. code-block:: latex
+
         .. math::
            MSE = \frac{1}{c*i*j} \sum{(I_1-I_2)^2}
+
      That after build turns into:
+
      .. math::
+
         MSE = \frac{1}{c*i*j} \sum{(I_1-I_2)^2}
+
      You can even use it inline as ``:math:` MSE = \frac{1}{c*i*j} \sum{(I_1-I_2)^2}``` that turns into :math:`MSE = \frac{1}{c*i*j} \sum{(I_1-I_2)^2}`.
      If you use some crazy LATEX library extension you need to add those to the ones to use at build time. Look into the file:`opencv/doc/conf.py` configuration file for more information on this.
    + Results. Well, here depending on your program show one of more of the following:
      - Console outputs by using the code block directive.
      - Output images.
      - Runtime videos, visualization. For this use your favorite screens capture software. `Camtasia Studio <http://www.techsmith.com/camtasia/>`_ certainly is one of the better choices, however their prices are out of this world. `CamStudio <http://camstudio.org/>`_ is a free alternative, but less powerful. If you do a video you can upload it to YouTube and then use the raw directive with HTML option to embed it into the generated web page:
+
        .. code-block:: rst
+
           You may observe a runtime instance of this on the `YouTube here <https://www.youtube.com/watch?v=jpBwHxsl1_0>`_.
+
           .. raw:: html
+
              <div align="center">
              <iframe title="Creating a video with OpenCV" width="560" height="349" src="http://www.youtube.com/embed/jpBwHxsl1_0?rel=0&loop=1" frameborder="0" allowfullscreen align="middle"></iframe>
              </div>
+
        This results in the text and video: You may observe a runtime instance of this on the `YouTube here <https://www.youtube.com/watch?v=jpBwHxsl1_0>`_.
+
        .. raw:: html
+
           <div align="center">
           <iframe title="Creating a video with OpenCV" width="560" height="349" src="http://www.youtube.com/embed/jpBwHxsl1_0?rel=0&loop=1" frameborder="0" allowfullscreen align="middle"></iframe>
           </div>
+
      When these aren't self-explanatory make sure to throw in a few guiding lines about what and why we can see.
    + Build the documentation and check for errors or warnings. In the CMake make sure you check or pass the option for building documentation. Then simply build the **docs** project for the PDF file and the **docs_html** project for the web page. Read the output of the build and check for errors/warnings for what you have added. This is also the time to observe and correct any kind of *not so good looking* parts. Remember to keep clean our build logs.
    + Read again your tutorial and check for both programming and spelling errors. If found any, please correct them.
+
 Take home the pride and joy of a job well done!
 ===============================================
+
 Once you are done contact me or dr. Gary Bradski with the tutorial. We may submit the tutorial ourselves to the trunk branch of our repository or ask you to do so.
 Now, to see your work **live** you may need to wait some time. The PDFs are updated usually at the launch of a new OpenCV version. The web pages are a little more diverse. They are automatically rebuilt in each evening. However, the **opencv.itseez.com** website contains only the most recent **stable branch** of OpenCV. Currently this is 2.3. When we add something new (like a tutorial) that first goes to the **trunk branch** of our repository. A build of this you may find on the **opencv.itseez.com/trunk** website. Although, we try to make a build every night occasionally we might freeze any of the branches to fix upcoming issues. During this it may take a little longer to see your work *live*, however if you submited it, be sure that eventually it will show up.
 If you have any questions or advices relating to this tutorial you can contact me at -delete-bernat@-delete-primeranks.net. Of course, delete the -delete- parts of that e-mail address.

doc/tutorials/ml/non_linear_svms/non_linear_svms.rst

@@ -2,56 +2,85 @@
 
 Support Vector Machines for Non-Linearly Separable Data
 *******************************************************
+
 Goal
 ====
 In this tutorial you will learn how to:
+
 .. container:: enumeratevisibleitemswithsquare
+
   + Define the optimization problem for SVMs when it is not possible to separate linearly the training data.
+
   + How to configure the parameters in :svms:`CvSVMParams <cvsvmparams>` to adapt your SVM for this class of problems.
+
 Motivation
 ==========
+
 Why is it interesting to extend the SVM optimation problem in order to handle non-linearly separable training data? Most of the applications in which SVMs are used in computer vision require a more powerful tool than a simple linear classifier. This stems from the fact that in these tasks **the training data can be rarely separated using an hyperplane**.
 Consider one of these tasks, for example, face detection. The training data in this case is composed by a set of images that are faces and another set of images that are non-faces (*every other thing in the world except from faces*). This training data is too complex so as to find a representation of each sample (*feature vector*) that could make the whole set of faces linearly separable from the whole set of non-faces.
+
 Extension of the Optimization Problem
 =====================================
+
 Remember that using SVMs we obtain a separating hyperplane. Therefore, since the training data is now non-linearly separable, we must admit that the hyperplane found will misclassify some of the samples. This *misclassification* is a new variable in the optimization that must be taken into account. The new model has to include both the old requirement of finding the hyperplane that gives the biggest margin and the new one of generalizing the training data correctly by not allowing too many classification errors.
 We start here from the formulation of the optimization problem of finding the hyperplane which maximizes the **margin** (this is explained in the :ref:`previous tutorial <introductiontosvms>`):
+
 .. math::
+
   \min_{\beta, \beta_{0}} L(\beta) = \frac{1}{2}||\beta||^{2} \text{ subject to } y_{i}(\beta^{T} x_{i} + \beta_{0}) \geq 1 \text{ } \forall i
+
 There are multiple ways in which this model can be modified so it takes into account the misclassification errors. For example, one could think of minimizing the same quantity plus a constant times the number of misclassification errors in the training data, i.e.:
+
 .. math::
+
   \min ||\beta||^{2} + C \text{(\# misclassication errors)}
+
 However, this one is not a very good solution since, among some other reasons, we do not distinguish between samples that are misclassified with a small distance to their appropriate decision region or samples that are not. Therefore, a better solution will take into account the *distance of the misclassified samples to their correct decision regions*, i.e.:
+
 .. math::
+
   \min ||\beta||^{2} + C \text{(distance of misclassified samples to their correct regions)}
+
 For each sample of the training data a new parameter :math:`\xi_{i}` is defined. Each one of these parameters contains the distance from its corresponding training sample to their correct decision region. The following picture shows non-linearly separable training data from two classes, a separating hyperplane and the distances to their correct regions of the samples that are misclassified.
+
 .. image:: images/sample-errors-dist.png
    :alt: Samples misclassified and their distances to their correct regions
    :align: center
-.. note:: Only the distances of the samples that are misclassified are shown in the picture. The distances of the rest of the samples are zero since they lay already in their correct decision region.
-The red and blue lines that appear on the picture are the margins to each one of the decision regions. It is very **important** to realize that each of the :math:`\xi_{i}` goes from a misclassified training sample to the margin of its appropriate region.
-Finally, the new formulation for the optimization problem is:
+
+.. note:: Only the distances of the samples that are misclassified are shown in the picture. The distances of the rest of the samples are zero since they lay already in their correct decision region. The red and blue lines that appear on the picture are the margins to each one of the decision regions. It is very **important** to realize that each of the :math:`\xi_{i}` goes from a misclassified training sample to the margin of its appropriate region. Finally, the new formulation for the optimization problem is:
+
 .. math::
+
   \min_{\beta, \beta_{0}} L(\beta) = ||\beta||^{2} + C \sum_{i} {\xi_{i}} \text{ subject to } y_{i}(\beta^{T} x_{i} + \beta_{0}) \geq 1 - \xi_{i} \text{ and } \xi_{i} \geq 0 \text{ } \forall i
+
 How should the parameter C be chosen? It is obvious that the answer to this question depends on how the training data is distributed. Although there is no general answer, it is useful to take into account these rules:
+
 .. container:: enumeratevisibleitemswithsquare
+
    * Large values of C give solutions with *less misclassification errors* but a *smaller margin*. Consider that in this case it is expensive to make misclassification errors. Since the aim of the optimization is to minimize the argument, few misclassifications errors are allowed.
+
    * Small values of C give solutions with *bigger margin* and *more classification errors*. In this case the minimization does not consider that much the term of the sum so it focuses more on finding a hyperplane with big margin.
+
 Source Code
 ===========
+
 You may also find the source code and these video file in the :file:`samples/cpp/tutorial_code/gpu/non_linear_svms/non_linear_svms` folder of the OpenCV source library or :download:`download it from here <../../../../samples/cpp/tutorial_code/ml/non_linear_svms/non_linear_svms.cpp>`.
+
 .. literalinclude:: ../../../../samples/cpp/tutorial_code/ml/non_linear_svms/non_linear_svms.cpp
    :language: cpp
    :linenos:
    :tab-width: 4
    :lines: 1-11, 22-23, 26-
+
 Explanation
 ===========
+
 1. **Set up the training data**
-  The training data of this exercise is formed by a set of labeled 2D-points that belong to one of two different classes. To make the exercise more appealing, the training data is generated randomly using a uniform probability density functions (PDFs).
-  We have divided the generation of the training data into two main parts.
-  In the first part we generate data for both classes that is linearly separable.
+
+  The training data of this exercise is formed by a set of labeled 2D-points that belong to one of two different classes. To make the exercise more appealing, the training data is generated randomly using a uniform probability density functions (PDFs). We have divided the generation of the training data into two main parts. In the first part we generate data for both classes that is linearly separable.
+
   .. code-block:: cpp
+
      // Generate random points for the class 1
      Mat trainClass = trainData.rowRange(0, nLinearSamples);
      // The x coordinate of the points is in [0, 0.4)
@@ -68,8 +97,11 @@ Explanation
      // The y coordinate of the points is in [0, 1)
      c = trainClass.colRange(1,2);
      rng.fill(c, RNG::UNIFORM, Scalar(1), Scalar(HEIGHT));
+
   In the second part we create data for both classes that is non-linearly separable, data that overlaps.
+
   .. code-block:: cpp
+
      // Generate random points for the classes 1 and 2
      trainClass = trainData.rowRange(  nLinearSamples, 2*NTRAINING_SAMPLES-nLinearSamples);
      // The x coordinate of the points is in [0.4, 0.6)
@@ -78,27 +110,43 @@ Explanation
      // The y coordinate of the points is in [0, 1)
      c = trainClass.colRange(1,2);
      rng.fill(c, RNG::UNIFORM, Scalar(1), Scalar(HEIGHT));
+
 2. **Set up SVM's parameters**
+
   .. seealso::
+
       In the previous tutorial :ref:`introductiontosvms` there is an explanation of the atributes of the class :svms:`CvSVMParams <cvsvmparams>` that we configure here before training the SVM.
+
   .. code-block:: cpp
+
      CvSVMParams params;
      params.svm_type    = SVM::C_SVC;
      params.C              = 0.1;
      params.kernel_type = SVM::LINEAR;
      params.term_crit   = TermCriteria(CV_TERMCRIT_ITER, (int)1e7, 1e-6);
+
   There are just two differences between the configuration we do here and the one that was done in the :ref:`previous tutorial <introductiontosvms>` that we use as reference.
+
   * *CvSVM::C_SVC*. We chose here a small value of this parameter in order not to punish too much the misclassification errors in the optimization. The idea of doing this stems from the will of obtaining a solution close to the one intuitively expected. However, we recommend to get a better insight of the problem by making adjustments to this parameter.
       .. note:: Here there are just very few points in the overlapping region between classes, giving a smaller value to **FRAC_LINEAR_SEP** the density of points can be incremented and the impact of the parameter **CvSVM::C_SVC** explored deeply.
+
   * *Termination Criteria of the algorithm*. The maximum number of iterations has to be increased considerably in order to solve correctly a problem with non-linearly separable training data. In particular, we have increased in five orders of magnitude this value.
+
 3. **Train the SVM**
+
   We call the method :svms:`CvSVM::train <cvsvm-train>` to build the SVM model. Watch out that the training process may take a quite long time. Have patiance when your run the program.
+
   .. code-block:: cpp
+
      CvSVM svm;
      svm.train(trainData, labels, Mat(), Mat(), params);
+
 4. **Show the Decision Regions**
+
   The method :svms:`CvSVM::predict <cvsvm-predict>` is used to classify an input sample using a trained SVM. In this example we have used this method in order to color the space depending on the prediction done by the SVM. In other words, an image is traversed interpreting its pixels as points of the Cartesian plane. Each of the points is colored depending on the class predicted by the SVM; in dark green if it is the class with label 1 and in dark blue if it is the class with label 2.
+
   .. code-block:: cpp
+
      Vec3b green(0,100,0), blue (100,0,0);
      for (int i = 0; i < I.rows; ++i)
           for (int j = 0; j < I.cols; ++j)
@@ -108,9 +156,13 @@ Explanation
                if      (response == 1)    I.at<Vec3b>(j, i)  = green;
                else if (response == 2)    I.at<Vec3b>(j, i)  = blue;
           }
+
 5. **Show the training data**
+
   The method :drawingFunc:`circle <circle>` is used to show the samples that compose the training data. The samples of the class labeled with 1 are shown in light green and in light blue the samples of the class labeled with 2.
+
   .. code-block:: cpp
+
      int thick = -1;
      int lineType = 8;
      float px, py;
@@ -128,9 +180,13 @@ Explanation
           py = trainData.at<float>(i,1);
           circle(I, Point( (int) px, (int) py ), 3, Scalar(255, 0, 0), thick, lineType);
      }
+
 6. **Support vectors**
+
   We use here a couple of methods to obtain information about the support vectors. The method :svms:`CvSVM::get_support_vector_count <cvsvm-get-support-vector>` outputs the total number of support vectors used in the problem and with the method :svms:`CvSVM::get_support_vector <cvsvm-get-support-vector>` we obtain each of the support vectors using an index. We have used this methods here to find the training examples that are support vectors and highlight them.
+
   .. code-block:: cpp
+
      thick = 2;
      lineType  = 8;
      int x     = svm.get_support_vector_count();
@@ -139,18 +195,25 @@ Explanation
           const float* v = svm.get_support_vector(i);
           circle(     I,  Point( (int) v[0], (int) v[1]), 6, Scalar(128, 128, 128), thick, lineType);
      }
+
 Results
 =======
+
 .. container:: enumeratevisibleitemswithsquare
+
    * The code opens an image and shows the training examples of both classes. The points of one class are represented with light green and light blue ones are used for the other class.
    * The SVM is trained and used to classify all the pixels of the image. This results in a division of the image in a blue region and a green region. The boundary between both regions is the separating hyperplane. Since the training data is non-linearly separable, it can be seen that some of the examples of both classes are misclassified; some green points lay on the blue region and some blue points lay on the green one.
    * Finally the support vectors are shown using gray rings around the training examples.
+
 .. image:: images/result.png
   :alt: Training data and decision regions given by the SVM
   :width: 300pt
   :align: center
+
 You may observe a runtime instance of this on the `YouTube here <https://www.youtube.com/watch?v=vFv2yPcSo-Q>`_.
+
 .. raw:: html
+
   <div align="center">
   <iframe title="Support Vector Machines for Non-Linearly Separable Data" width="560" height="349" src="http://www.youtube.com/embed/vFv2yPcSo-Q?rel=0&loop=1" frameborder="0" allowfullscreen align="middle"></iframe>
   </div>

doc/tutorials/tutorials.rst

@@ -156,6 +156,21 @@ As always, we would be happy to hear your comments and receive your contribution
                  :width:  80pt
                  :alt: gpu icon
 
+*  :ref:`Table-Of-Content-Contrib`
+
+   .. tabularcolumns:: m{100pt} m{300pt}
+   .. cssclass:: toctableopencv
+
+   =========== =======================================================
+   |Contrib|       Discover additional contribution to OpenCV.
+
+   =========== =======================================================
+
+   .. |Contrib| image:: images/retina.jpg
+                 :height: 80pt
+                 :width:  80pt
+                 :alt: gpu icon
+
 *  :ref:`Table-Of-Content-iOS`
 
    .. tabularcolumns:: m{100pt} m{300pt}
@@ -204,5 +219,6 @@ As always, we would be happy to hear your comments and receive your contribution
    objdetect/table_of_content_objdetect/table_of_content_objdetect
    ml/table_of_content_ml/table_of_content_ml
    gpu/table_of_content_gpu/table_of_content_gpu
+   contrib/table_of_content_contrib/table_of_content_contrib
    ios/table_of_content_ios/table_of_content_ios
    general/table_of_content_general/table_of_content_general

ios/build_framework.py

@@ -13,16 +13,16 @@ Script will create <outputdir>, if it's missing, and a few its subdirectories:
 
     <outputdir>
         build/
-            iPhoneOS/
+            iPhoneOS-*/
                [cmake-generated build tree for an iOS device target]
             iPhoneSimulator/
                [cmake-generated build tree for iOS simulator]
-        OpenCV.framework/
+        opencv2.framework/
             [the framework content]
 
 The script should handle minor OpenCV updates efficiently
 - it does not recompile the library from scratch each time.
-However, OpenCV.framework directory is erased and recreated on each run.
+However, opencv2.framework directory is erased and recreated on each run.
 """
 
 import glob, re, os, os.path, shutil, string, sys

ios/cmake/Modules/Platform/iOS.cmake

@@ -40,7 +40,7 @@ set (CMAKE_CXX_OSX_CURRENT_VERSION_FLAG "${CMAKE_C_OSX_CURRENT_VERSION_FLAG}")
 
 # Hidden visibilty is required for cxx on iOS
 set (CMAKE_C_FLAGS "")
-set (CMAKE_CXX_FLAGS "-headerpad_max_install_names -fvisibility=hidden -fvisibility-inlines-hidden")
+set (CMAKE_CXX_FLAGS "-stdlib=libc++ -headerpad_max_install_names -fvisibility=hidden -fvisibility-inlines-hidden")
 
 set (CMAKE_CXX_FLAGS_RELEASE "-DNDEBUG -O3 -fomit-frame-pointer -ffast-math")
 

ios/cmake/Toolchains/Toolchain-iPhoneOS_Xcode.cmake

@@ -8,8 +8,8 @@ set (CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_SOURCE_DIR}/ios/cma
 
 # Force the compilers to gcc for iOS
 include (CMakeForceCompiler)
-CMAKE_FORCE_C_COMPILER (gcc gcc)
-CMAKE_FORCE_CXX_COMPILER (g++ g++)
+#CMAKE_FORCE_C_COMPILER (gcc gcc)
+#CMAKE_FORCE_CXX_COMPILER (g++ g++)
 
 set (CMAKE_C_SIZEOF_DATA_PTR 4)
 set (CMAKE_C_HAS_ISYSROOT 1)

ios/cmake/Toolchains/Toolchain-iPhoneSimulator_Xcode.cmake

@@ -8,8 +8,8 @@ set (CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_SOURCE_DIR}/ios/cma
 
 # Force the compilers to gcc for iOS
 include (CMakeForceCompiler)
-CMAKE_FORCE_C_COMPILER (gcc gcc)
-CMAKE_FORCE_CXX_COMPILER (g++ g++)
+#CMAKE_FORCE_C_COMPILER (gcc gcc)
+#CMAKE_FORCE_CXX_COMPILER (g++ g++)
 
 set (CMAKE_C_SIZEOF_DATA_PTR 4)
 set (CMAKE_C_HAS_ISYSROOT 1)

modules/androidcamera/CMakeLists.txt

@@ -6,7 +6,7 @@ set(the_description "Auxiliary module for Android native camera support")
 set(OPENCV_MODULE_TYPE STATIC)
 
 ocv_define_module(androidcamera INTERNAL opencv_core log dl)
-ocv_include_directories("${CMAKE_CURRENT_SOURCE_DIR}/camera_wrapper")
+ocv_include_directories("${CMAKE_CURRENT_SOURCE_DIR}/camera_wrapper" "${OpenCV_SOURCE_DIR}/android/service/engine/jni/include")
 
 # Android source tree for native camera
 SET (ANDROID_SOURCE_TREE "ANDROID_SOURCE_TREE-NOTFOUND" CACHE PATH

modules/androidcamera/camera_wrapper/camera_wrapper.cpp

@@ -1,4 +1,4 @@
-#if !defined(ANDROID_r2_2_0) && !defined(ANDROID_r2_3_3) && !defined(ANDROID_r3_0_1) && !defined(ANDROID_r4_0_0) && !defined(ANDROID_r4_0_3) && !defined(ANDROID_r4_1_1)
+#if !defined(ANDROID_r2_2_0) && !defined(ANDROID_r2_3_3) && !defined(ANDROID_r3_0_1) && !defined(ANDROID_r4_0_0) && !defined(ANDROID_r4_0_3) && !defined(ANDROID_r4_1_1) && !defined(ANDROID_r4_2_0)
 # error Building camera wrapper for your version of Android is not supported by OpenCV. You need to modify OpenCV sources in order to compile camera wrapper for your version of Android.
 #endif
 
@@ -18,7 +18,7 @@
 # define MAGIC_OPENCV_TEXTURE_ID (0x10)
 #else // defined(ANDROID_r3_0_1) || defined(ANDROID_r4_0_0) || defined(ANDROID_r4_0_3)
 //TODO: This is either 2.2 or 2.3. Include the headers for ISurface.h access
-#if defined(ANDROID_r4_1_1)
+#if defined(ANDROID_r4_1_1) || defined(ANDROID_r4_2_0)
 #include <gui/ISurface.h>
 #include <gui/BufferQueue.h>
 #else
@@ -60,7 +60,7 @@ using namespace android;
 
 void debugShowFPS();
 
-#if defined(ANDROID_r4_1_1)
+#if defined(ANDROID_r4_1_1) || defined(ANDROID_r4_2_0)
 class ConsumerListenerStub: public BufferQueue::ConsumerListener
 {
 public:
@@ -280,7 +280,7 @@ public:
     }
 
     virtual void postData(int32_t msgType, const sp<IMemory>& dataPtr
-#if defined(ANDROID_r4_0_0) || defined(ANDROID_r4_0_3) || defined(ANDROID_r4_1_1)
+    #if defined(ANDROID_r4_0_0) || defined(ANDROID_r4_0_3) || defined(ANDROID_r4_1_1) || defined(ANDROID_r4_2_0)
                           ,camera_frame_metadata_t*
 #endif
                           )
@@ -526,7 +526,7 @@ CameraHandler* CameraHandler::initCameraConnect(const CameraCallback& callback,
     pdstatus = camera->setPreviewTexture(surfaceTexture);
     if (pdstatus != 0)
         LOGE("initCameraConnect: failed setPreviewTexture call; camera migth not work correctly");
-#elif defined(ANDROID_r4_1_1)
+#elif defined(ANDROID_r4_1_1) || defined(ANDROID_r4_2_0)
     sp<BufferQueue> bufferQueue = new BufferQueue();
     sp<BufferQueue::ConsumerListener> queueListener = new ConsumerListenerStub();
     bufferQueue->consumerConnect(queueListener);

modules/androidcamera/src/camera_activity.cpp

@@ -9,6 +9,7 @@
 #include <opencv2/core/version.hpp>
 #include "camera_activity.hpp"
 #include "camera_wrapper.h"
+#include "EngineCommon.h"
 
 #undef LOG_TAG
 #undef LOGE
@@ -267,12 +268,13 @@ void CameraWrapperConnector::fillListWrapperLibs(const string& folderPath, vecto
 
 std::string CameraWrapperConnector::getDefaultPathLibFolder()
 {
-    const string packageList[] = {"tegra3", "armv7a_neon", "armv7a", "armv5", "x86"};
-    for (size_t i = 0; i < 5; i++)
+    #define BIN_PACKAGE_NAME(x) "org.opencv.lib_v" CVAUX_STR(CV_MAJOR_VERSION) CVAUX_STR(CV_MINOR_VERSION) "_" x
+    const char* const packageList[] = {BIN_PACKAGE_NAME("armv7a"), OPENCV_ENGINE_PACKAGE};
+    for (size_t i = 0; i < sizeof(packageList)/sizeof(packageList[0]); i++)
     {
         char path[128];
-        sprintf(path, "/data/data/org.opencv.lib_v%d%d_%s/lib/", CV_MAJOR_VERSION, CV_MINOR_VERSION, packageList[i].c_str());
-        LOGD("Trying package \"%s\" (\"%s\")", packageList[i].c_str(), path);
+        sprintf(path, "/data/data/%s/lib/", packageList[i]);
+        LOGD("Trying package \"%s\" (\"%s\")", packageList[i], path);
 
         DIR* dir = opendir(path);
         if (!dir)
@@ -427,7 +429,6 @@ void CameraActivity::applyProperties()
 
 int CameraActivity::getFrameWidth()
 {
-    LOGD("CameraActivity::getFrameWidth()");
     if (frameWidth <= 0)
     frameWidth = getProperty(ANDROID_CAMERA_PROPERTY_FRAMEWIDTH);
     return frameWidth;
@@ -435,7 +436,6 @@ int CameraActivity::getFrameWidth()
 
 int CameraActivity::getFrameHeight()
 {
-    LOGD("CameraActivity::getFrameHeight()");
     if (frameHeight <= 0)
     frameHeight = getProperty(ANDROID_CAMERA_PROPERTY_FRAMEHEIGHT);
     return frameHeight;

modules/calib3d/perf/perf_pnp.cpp

@@ -55,7 +55,7 @@ PERF_TEST_P(PointsNum_Algo, solvePnP,
     }
 
     SANITY_CHECK(rvec, 1e-6);
-    SANITY_CHECK(tvec, 1e-6);
+    SANITY_CHECK(tvec, 1e-3);
 }
 
 PERF_TEST(PointsNum_Algo, solveP3P)
@@ -86,6 +86,7 @@ PERF_TEST(PointsNum_Algo, solveP3P)
     add(points2d, noise, points2d);
 
     declare.in(points3d, points2d);
+    declare.time(100);
 
     TEST_CYCLE_N(1000)
     {

modules/calib3d/perf/perf_precomp.hpp

@@ -1,6 +1,9 @@
 #ifdef __GNUC__
 #  pragma GCC diagnostic ignored "-Wmissing-declarations"
-#  pragma GCC diagnostic ignored "-Wmissing-prototypes" //OSX
+#  if defined __clang__ || defined __APPLE__
+#    pragma GCC diagnostic ignored "-Wmissing-prototypes"
+#    pragma GCC diagnostic ignored "-Wextra"
+#  endif
 #endif
 
 #ifndef __OPENCV_PERF_PRECOMP_HPP__

modules/calib3d/test/test_cameracalibration_artificial.cpp

@@ -426,4 +426,4 @@ protected:
     }
 };
 
-TEST(Calib3d_CalibrateCamera_CPP, accuracy_on_artificial_data) { CV_CalibrateCameraArtificialTest test; test.safe_run(); }
+TEST(Calib3d_CalibrateCamera_CPP, DISABLED_accuracy_on_artificial_data) { CV_CalibrateCameraArtificialTest test; test.safe_run(); }

modules/calib3d/test/test_precomp.hpp

@@ -1,6 +1,9 @@
 #ifdef __GNUC__
 #  pragma GCC diagnostic ignored "-Wmissing-declarations"
-#  pragma GCC diagnostic ignored "-Wmissing-prototypes" //OSX
+#  if defined __clang__ || defined __APPLE__
+#    pragma GCC diagnostic ignored "-Wmissing-prototypes"
+#    pragma GCC diagnostic ignored "-Wextra"
+#  endif
 #endif
 
 #ifndef __OPENCV_TEST_PRECOMP_HPP__

modules/contrib/doc/contrib.rst

@@ -10,3 +10,4 @@ The module contains some recently added functionality that has not been stabiliz
     stereo
     FaceRecognizer Documentation <facerec/index>
     Retina Documentation <retina/index>
+    openfabmap

modules/contrib/doc/facerec/src/create_csv.py

@@ -1,3 +1,5 @@
+#/usr/bin/env python
+
 import sys
 import os.path
 

modules/contrib/doc/openfabmap.rst

@@ -1,4 +1,4 @@
-openFABMAP
+OpenFABMAP
 ========================================
 
 .. highlight:: cpp

modules/contrib/doc/retina/index.rst

@@ -14,6 +14,8 @@ Class which provides the main controls to the Gipsa/Listic labs human  retina mo
 
 * periphearal vision for sensitive transient signals detection (motion and events) : the magnocellular pathway.
 
+**NOTE : See the Retina tutorial in the tutorial/contrib section for complementary explanations.**
+
 The retina can be settled up with various parameters, by default, the retina cancels mean luminance and enforces all details of the visual scene. In order to use your own parameters, you can use at least one time the *write(std::string fs)* method which will write a proper XML file with all default parameters. Then, tweak it on your own and reload them at any time using method *setup(std::string fs)*. These methods update a *Retina::RetinaParameters* member structure that is described hereafter. ::
 
   class Retina
@@ -98,7 +100,9 @@ This retina filter code includes the research contributions of phd/research coll
 Demos and experiments !
 =======================
 
-Take a look at the C++ examples provided with OpenCV :
+**NOTE : Complementary to the following examples, have a look at the Retina tutorial in the tutorial/contrib section for complementary explanations.**
+
+Take a look at the provided C++ examples provided with OpenCV :
 
 * **samples/cpp/retinademo.cpp** shows how to use the retina module for details enhancement (Parvo channel output) and transient maps observation (Magno channel output). You can play with images, video sequences and webcam video.
     Typical uses are (provided your OpenCV installation is situated in folder *OpenCVReleaseFolder*)
@@ -122,6 +126,7 @@ Take a look at the C++ examples provided with OpenCV :
 
       Note that some sliders are made available to allow you to play with luminance compression.
 
+
 Methods description
 ===================
 
@@ -203,7 +208,7 @@ Retina::getMagno
 Retina::getParameters
 +++++++++++++++++++++
 
-.. ocv:function:: struct Retina::RetinaParameters Retina::getParameters()
+.. ocv:function:: Retina::RetinaParameters Retina::getParameters()
 
     Retrieve the current parameters values in a *Retina::RetinaParameters* structure
 
@@ -318,7 +323,8 @@ Retina::RetinaParameters
 ========================
 
 .. ocv:struct:: Retina::RetinaParameters
-This structure merges all the parameters that can be adjusted threw the **Retina::setup()**, **Retina::setupOPLandIPLParvoChannel** and **Retina::setupIPLMagnoChannel** setup methods
+
+  This structure merges all the parameters that can be adjusted threw the **Retina::setup()**, **Retina::setupOPLandIPLParvoChannel** and **Retina::setupIPLMagnoChannel** setup methods
 Parameters structure for better clarity, check explenations on the comments of methods : setupOPLandIPLParvoChannel and setupIPLMagnoChannel. ::
 
     class RetinaParameters{

modules/contrib/include/opencv2/contrib/contrib.hpp

@@ -583,7 +583,7 @@ namespace cv
         virtual ~StereoVar();
 
         //! the stereo correspondence operator that computes disparity map for the specified rectified stereo pair
-        CV_WRAP_AS(compute) virtual void operator()(const Mat& left, const Mat& right, Mat& disp);
+        CV_WRAP_AS(compute) virtual void operator()(const Mat& left, const Mat& right, CV_OUT Mat& disp);
 
         CV_PROP_RW int      levels;
         CV_PROP_RW double   pyrScale;

modules/contrib/src/detection_based_tracker.cpp

@@ -1,6 +1,8 @@
 #if defined(__linux__) || defined(LINUX) || defined(__APPLE__) || defined(ANDROID)
 #include "opencv2/contrib/detection_based_tracker.hpp"
 
+#include <pthread.h>
+
 #define DEBUGLOGS 1
 
 #ifdef ANDROID

modules/contrib/src/facerec.cpp

@@ -300,7 +300,13 @@ public:
 //------------------------------------------------------------------------------
 // FaceRecognizer
 //------------------------------------------------------------------------------
-void FaceRecognizer::update(InputArrayOfArrays, InputArray) {
+void FaceRecognizer::update(InputArrayOfArrays src, InputArray labels ) {
+    if( dynamic_cast<LBPH*>(this) != 0 )
+    {
+        dynamic_cast<LBPH*>(this)->update( src, labels );
+        return;
+    }
+    
     string error_msg = format("This FaceRecognizer (%s) does not support updating, you have to use FaceRecognizer::train to update it.", this->name().c_str());
     CV_Error(CV_StsNotImplemented, error_msg);
 }

modules/contrib/test/test_precomp.hpp

@@ -1,6 +1,9 @@
 #ifdef __GNUC__
 #  pragma GCC diagnostic ignored "-Wmissing-declarations"
-#  pragma GCC diagnostic ignored "-Wmissing-prototypes" //OSX
+#  if defined __clang__ || defined __APPLE__
+#    pragma GCC diagnostic ignored "-Wmissing-prototypes"
+#    pragma GCC diagnostic ignored "-Wextra"
+#  endif
 #endif
 
 #ifndef __OPENCV_TEST_PRECOMP_HPP__

modules/core/doc/operations_on_arrays.rst

@@ -13,17 +13,17 @@ Calculates an absolute value of each matrix element.
     :param m: matrix.
     :param e: matrix expression.
 
-``abs`` is a meta-function that is expanded to one of :ocv:func:`absdiff` forms:
+``abs`` is a meta-function that is expanded to one of :ocv:func:`absdiff` or :ocv:func:`convertScaleAbs` forms:
 
     * ``C = abs(A-B)``     is equivalent to ``absdiff(A, B, C)``
 
     * ``C = abs(A)``     is equivalent to ``absdiff(A, Scalar::all(0), C)``
 
-    * ``C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta))``     is equivalent to :ocv:funcx:`convertScaleAbs` (A, C, alpha, beta)
+    * ``C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta))``     is equivalent to  ``convertScaleAbs(A, C, alpha, beta)``
 
 The output matrix has the same size and the same type as the input one except for the last case, where ``C`` is ``depth=CV_8U`` .
 
-    .. seealso:: :ref:`MatrixExpressions`, :ocv:func:`absdiff`
+    .. seealso:: :ref:`MatrixExpressions`, :ocv:func:`absdiff`, :ocv:func:`convertScaleAbs`
 
 
 absdiff

modules/core/include/opencv2/core/core.hpp

@@ -204,11 +204,11 @@ CV_EXPORTS ErrorCallback redirectError( ErrorCallback errCallback,
 #ifdef __GNUC__
 #define CV_Error( code, msg ) cv::error( cv::Exception(code, msg, __func__, __FILE__, __LINE__) )
 #define CV_Error_( code, args ) cv::error( cv::Exception(code, cv::format args, __func__, __FILE__, __LINE__) )
-#define CV_Assert( expr ) if((expr)) ; else cv::error( cv::Exception(CV_StsAssert, #expr, __func__, __FILE__, __LINE__) )
+#define CV_Assert( expr ) if(!!(expr)) ; else cv::error( cv::Exception(CV_StsAssert, #expr, __func__, __FILE__, __LINE__) )
 #else
 #define CV_Error( code, msg ) cv::error( cv::Exception(code, msg, "", __FILE__, __LINE__) )
 #define CV_Error_( code, args ) cv::error( cv::Exception(code, cv::format args, "", __FILE__, __LINE__) )
-#define CV_Assert( expr ) if((expr)) ; else cv::error( cv::Exception(CV_StsAssert, #expr, "", __FILE__, __LINE__) )
+#define CV_Assert( expr ) if(!!(expr)) ; else cv::error( cv::Exception(CV_StsAssert, #expr, "", __FILE__, __LINE__) )
 #endif
 
 #ifdef _DEBUG
@@ -4341,15 +4341,24 @@ public:
     CV_WRAP vector<Mat> getMatVector(const string& name) const;
     CV_WRAP Ptr<Algorithm> getAlgorithm(const string& name) const;
 
-    CV_WRAP_AS(setInt) void set(const string& name, int value);
-    CV_WRAP_AS(setDouble) void set(const string& name, double value);
-    CV_WRAP_AS(setBool) void set(const string& name, bool value);
-    CV_WRAP_AS(setString) void set(const string& name, const string& value);
-    CV_WRAP_AS(setMat) void set(const string& name, const Mat& value);
-    CV_WRAP_AS(setMatVector) void set(const string& name, const vector<Mat>& value);
-    CV_WRAP_AS(setAlgorithm) void set(const string& name, const Ptr<Algorithm>& value);
+    void set(const string& name, int value);
+    void set(const string& name, double value);
+    void set(const string& name, bool value);
+    void set(const string& name, const string& value);
+    void set(const string& name, const Mat& value);
+    void set(const string& name, const vector<Mat>& value);
+    void set(const string& name, const Ptr<Algorithm>& value);
     template<typename _Tp> void set(const string& name, const Ptr<_Tp>& value);
 
+    CV_WRAP void setInt(const string& name, int value);
+    CV_WRAP void setDouble(const string& name, double value);
+    CV_WRAP void setBool(const string& name, bool value);
+    CV_WRAP void setString(const string& name, const string& value);
+    CV_WRAP void setMat(const string& name, const Mat& value);
+    CV_WRAP void setMatVector(const string& name, const vector<Mat>& value);
+    CV_WRAP void setAlgorithm(const string& name, const Ptr<Algorithm>& value);
+    template<typename _Tp> void setAlgorithm(const string& name, const Ptr<_Tp>& value);
+
     void set(const char* name, int value);
     void set(const char* name, double value);
     void set(const char* name, bool value);
@@ -4359,6 +4368,15 @@ public:
     void set(const char* name, const Ptr<Algorithm>& value);
     template<typename _Tp> void set(const char* name, const Ptr<_Tp>& value);
 
+    void setInt(const char* name, int value);
+    void setDouble(const char* name, double value);
+    void setBool(const char* name, bool value);
+    void setString(const char* name, const string& value);
+    void setMat(const char* name, const Mat& value);
+    void setMatVector(const char* name, const vector<Mat>& value);
+    void setAlgorithm(const char* name, const Ptr<Algorithm>& value);
+    template<typename _Tp> void setAlgorithm(const char* name, const Ptr<_Tp>& value);
+
     CV_WRAP string paramHelp(const string& name) const;
     int paramType(const char* name) const;
     CV_WRAP int paramType(const string& name) const;