temporary disable performance test for alphaComp function(cherry picked from commit 1ce5165cb7)

Dead code removed as this cannot be null in Java.
(cherry picked from commit dbe7634286)
2026-07-25 21:33:04 +04:00 · 2014-02-14 17:12:31 +04:00 · 2014-02-13 20:13:47 +04:00 · 2014-02-13 20:13:38 +04:00 · 2014-02-13 20:13:27 +04:00 · 2014-02-13 17:59:23 +04:00
382 changed files with 3328 additions and 22084 deletions
@@ -1,7 +1,6 @@
 *.autosave
 *.pyc
 *.user
-*~
 .*.swp
 .DS_Store
 .sw[a-z]
@@ -1,2 +0,0 @@
-[tgit]
-    icon = doc/opencv.ico
@@ -210,7 +210,7 @@
 #include <string>
 #endif 

-#if defined(__linux__) || defined(__APPLE__) || defined(__MACOSX)
+#if defined(linux) || defined(__APPLE__) || defined(__MACOSX)
 #include <alloca.h>

 #include <emmintrin.h>
@@ -54,7 +54,7 @@

 /* Native cpu byte order: 1 if big-endian (Motorola) or 0 if little-endian
   (Intel) */
-#define HOST_BIGENDIAN @WORDS_BIGENDIAN@
+#define HOST_BIGENDIAN 0

 /* Set the native cpu bit order (FILLORDER_LSB2MSB or FILLORDER_MSB2LSB) */
 #define HOST_FILLORDER FILLORDER_LSB2MSB
@@ -156,7 +156,15 @@

 /* Define WORDS_BIGENDIAN to 1 if your processor stores words with the most
   significant byte first (like Motorola and SPARC, unlike Intel). */
-#cmakedefine WORDS_BIGENDIAN 1
+#if defined AC_APPLE_UNIVERSAL_BUILD
+# if defined __BIG_ENDIAN__
+#  define WORDS_BIGENDIAN 1
+# endif
+#else
+# ifndef WORDS_BIGENDIAN
+/* #  undef WORDS_BIGENDIAN */
+# endif
+#endif

 /* Support Deflate compression */
 #define ZIP_SUPPORT 1
@@ -128,7 +128,6 @@ OCV_OPTION(WITH_1394           "Include IEEE1394 support"                    ON
 OCV_OPTION(WITH_AVFOUNDATION   "Use AVFoundation for Video I/O"              ON   IF IOS)
 OCV_OPTION(WITH_CARBON         "Use Carbon for UI instead of Cocoa"          OFF  IF APPLE )
 OCV_OPTION(WITH_CUDA           "Include NVidia Cuda Runtime support"         ON   IF (CMAKE_VERSION VERSION_GREATER "2.8" AND NOT IOS) )
-OCV_OPTION(WITH_VTK            "Include VTK library support (and build opencv_viz module eiher)"             OFF IF (NOT ANDROID AND NOT IOS) )
 OCV_OPTION(WITH_CUFFT          "Include NVidia Cuda Fast Fourier Transform (FFT) library support"            ON  IF (CMAKE_VERSION VERSION_GREATER "2.8" AND NOT IOS) )
 OCV_OPTION(WITH_CUBLAS         "Include NVidia Cuda Basic Linear Algebra Subprograms (BLAS) library support" OFF IF (CMAKE_VERSION VERSION_GREATER "2.8" AND NOT IOS) )
 OCV_OPTION(WITH_NVCUVID        "Include NVidia Video Decoding library support"                               OFF IF (CMAKE_VERSION VERSION_GREATER "2.8" AND NOT ANDROID AND NOT IOS AND NOT APPLE) )
@@ -142,7 +141,7 @@ OCV_OPTION(WITH_IPP            "Include Intel IPP support"                   OFF
 OCV_OPTION(WITH_JASPER         "Include JPEG2K support"                      ON   IF (NOT IOS) )
 OCV_OPTION(WITH_JPEG           "Include JPEG support"                        ON)
 OCV_OPTION(WITH_OPENEXR        "Include ILM support via OpenEXR"             ON   IF (NOT IOS) )
-OCV_OPTION(WITH_OPENGL         "Include OpenGL support"                      OFF  IF (NOT ANDROID) )
+OCV_OPTION(WITH_OPENGL         "Include OpenGL support"                      OFF  IF (NOT ANDROID AND NOT APPLE) )
 OCV_OPTION(WITH_OPENNI         "Include OpenNI support"                      OFF  IF (NOT ANDROID AND NOT IOS) )
 OCV_OPTION(WITH_PNG            "Include PNG support"                         ON)
 OCV_OPTION(WITH_PVAPI          "Include Prosilica GigE support"              ON   IF (NOT ANDROID AND NOT IOS) )
@@ -206,7 +205,6 @@ OCV_OPTION(ENABLE_DYNAMIC_CUDA        "Enabled dynamic CUDA linkage"
 OCV_OPTION(ENABLE_PRECOMPILED_HEADERS "Use precompiled headers"                                  ON   IF (NOT IOS) )
 OCV_OPTION(ENABLE_SOLUTION_FOLDERS    "Solution folder in Visual Studio or in other IDEs"        (MSVC_IDE OR CMAKE_GENERATOR MATCHES Xcode) IF (CMAKE_VERSION VERSION_GREATER "2.8.0") )
 OCV_OPTION(ENABLE_PROFILING           "Enable profiling in the GCC compiler (Add flags: -g -pg)" OFF  IF CMAKE_COMPILER_IS_GNUCXX )
-OCV_OPTION(ENABLE_COVERAGE            "Enable coverage collection with  GCov"                    OFF  IF CMAKE_COMPILER_IS_GNUCXX )
 OCV_OPTION(ENABLE_OMIT_FRAME_POINTER  "Enable -fomit-frame-pointer for GCC"                      ON   IF CMAKE_COMPILER_IS_GNUCXX AND NOT (APPLE AND CMAKE_COMPILER_IS_CLANGCXX) )
 OCV_OPTION(ENABLE_POWERPC             "Enable PowerPC for GCC"                                   ON   IF (CMAKE_COMPILER_IS_GNUCXX AND CMAKE_SYSTEM_PROCESSOR MATCHES powerpc.*) )
 OCV_OPTION(ENABLE_FAST_MATH           "Enable -ffast-math (not recommended for GCC 4.6.x)"       OFF  IF (CMAKE_COMPILER_IS_GNUCXX AND (X86 OR X86_64)) )
@@ -445,19 +443,6 @@ endif()
 include(cmake/OpenCVPCHSupport.cmake)
 include(cmake/OpenCVModule.cmake)

-# ----------------------------------------------------------------------------
-#  Detect endianness of build platform
-# ----------------------------------------------------------------------------
-
-if(CMAKE_SYSTEM_NAME STREQUAL iOS)
-  # test_big_endian needs try_compile, which doesn't work for iOS
-  # http://public.kitware.com/Bug/view.php?id=12288
-  set(WORDS_BIGENDIAN 0)
-else()
-  include(TestBigEndian)
-  test_big_endian(WORDS_BIGENDIAN)
-endif()
-
 # ----------------------------------------------------------------------------
 #  Detect 3rd-party libraries
 # ----------------------------------------------------------------------------
@@ -467,6 +452,7 @@ include(cmake/OpenCVFindLibsGUI.cmake)
 include(cmake/OpenCVFindLibsVideo.cmake)
 include(cmake/OpenCVFindLibsPerf.cmake)

+
 # ----------------------------------------------------------------------------
 #  Detect other 3rd-party libraries/tools
 # ----------------------------------------------------------------------------
@@ -502,9 +488,6 @@ if(WITH_OPENCL)
  include(cmake/OpenCVDetectOpenCL.cmake)
 endif()

-# --- VTK support ---
-include(cmake/OpenCVDetectVTK.cmake)
-
 # ----------------------------------------------------------------------------
 # Add CUDA libraries (needed for apps/tools, samples)
 # ----------------------------------------------------------------------------
@@ -782,7 +765,6 @@ else()
 endif()

 status("    OpenGL support:" HAVE_OPENGL THEN "YES (${OPENGL_LIBRARIES})" ELSE NO)
-status("    VTK support:" HAVE_VTK THEN "YES (ver ${VTK_VERSION})" ELSE NO)

 # ========================== MEDIA IO ==========================
 status("")
@@ -1,7 +1,5 @@
 ### OpenCV: Open Source Computer Vision Library

-[![Gittip](http://img.shields.io/gittip/OpenCV.png)](https://www.gittip.com/OpenCV/)
-
 #### Resources

 * Homepage: <http://opencv.org>
@@ -20,3 +18,6 @@ Summary of guidelines:
 * Include tests and documentation;
 * Clean up "oops" commits before submitting;
 * Follow the coding style guide.
+
+[![Donate OpenCV project](http://opencv.org/wp-content/uploads/2013/07/gittip1.png)](https://www.gittip.com/OpenCV/)
+[![Donate OpenCV project](http://opencv.org/wp-content/uploads/2013/07/paypal-donate-button.png)](https://www.paypal.com/cgi-bin/webscr?item_name=Donation+to+OpenCV&cmd=_donations&business=accountant%40opencv.org)
@@ -338,7 +338,7 @@ typedef enum CvBoostType
    CV_LKCLASS  = 5, /* classification (K class problem)    */
    CV_LSREG    = 6, /* least squares regression            */
    CV_LADREG   = 7, /* least absolute deviation regression */
-    CV_MREG     = 8  /* M-regression (Huber loss)           */
+    CV_MREG     = 8, /* M-regression (Huber loss)           */
 } CvBoostType;

 /****************************************************************************************\
@@ -187,11 +187,6 @@ if(CMAKE_COMPILER_IS_GNUCXX)
    add_extra_compiler_option(-ffunction-sections)
  endif()

-  if(ENABLE_COVERAGE)
-    set(OPENCV_EXTRA_C_FLAGS "${OPENCV_EXTRA_C_FLAGS} --coverage")
-    set(OPENCV_EXTRA_CXX_FLAGS "${OPENCV_EXTRA_CXX_FLAGS} --coverage")
-  endif()
-
  set(OPENCV_EXTRA_FLAGS_RELEASE "${OPENCV_EXTRA_FLAGS_RELEASE} -DNDEBUG")
  set(OPENCV_EXTRA_FLAGS_DEBUG "${OPENCV_EXTRA_FLAGS_DEBUG} -O0 -DDEBUG -D_DEBUG")
 endif()
@@ -326,12 +326,12 @@ macro(add_android_project target path)

      # copy all needed CUDA libs to project if EMBED_CUDA flag is present
      if(android_proj_EMBED_CUDA)
-        set(android_proj_culibs ${CUDA_npp_LIBRARY_ABS} ${CUDA_LIBRARIES_ABS})
+        set(android_proj_culibs ${CUDA_npp_LIBRARY} ${CUDA_LIBRARIES})
        if(HAVE_CUFFT)
-          list(INSERT android_proj_culibs 0 ${CUDA_cufft_LIBRARY_ABS})
+          list(INSERT android_proj_culibs 0 ${CUDA_cufft_LIBRARY})
        endif()
        if(HAVE_CUBLAS)
-          list(INSERT android_proj_culibs 0 ${CUDA_cublas_LIBRARY_ABS})
+          list(INSERT android_proj_culibs 0 ${CUDA_cublas_LIBRARY})
        endif()
        foreach(lib ${android_proj_culibs})
          get_filename_component(f "${lib}" NAME)
@@ -180,9 +180,6 @@ if(CUDA_FOUND)
      # we remove -Wsign-promo as it generates warnings under linux
      string(REPLACE "-Wsign-promo" "" ${var} "${${var}}")

-      # we remove -Wno-sign-promo as it generates warnings under linux
-      string(REPLACE "-Wno-sign-promo" "" ${var} "${${var}}")
-
      # we remove -Wno-delete-non-virtual-dtor because it's used for C++ compiler
      # but NVCC uses C compiler by default
      string(REPLACE "-Wno-delete-non-virtual-dtor" "" ${var} "${${var}}")
@@ -219,42 +216,3 @@ else()
  unset(CUDA_ARCH_BIN CACHE)
  unset(CUDA_ARCH_PTX CACHE)
 endif()
-
-if(HAVE_CUDA)
-  set(CUDA_LIBS_PATH "")
-  foreach(p ${CUDA_LIBRARIES} ${CUDA_npp_LIBRARY})
-    get_filename_component(_tmp ${p} PATH)
-    list(APPEND CUDA_LIBS_PATH ${_tmp})
-  endforeach()
-
-  if(HAVE_CUBLAS)
-    foreach(p ${CUDA_cublas_LIBRARY})
-      get_filename_component(_tmp ${p} PATH)
-      list(APPEND CUDA_LIBS_PATH ${_tmp})
-    endforeach()
-  endif()
-
-  if(HAVE_CUFFT)
-    foreach(p ${CUDA_cufft_LIBRARY})
-      get_filename_component(_tmp ${p} PATH)
-      list(APPEND CUDA_LIBS_PATH ${_tmp})
-    endforeach()
-  endif()
-
-  list(REMOVE_DUPLICATES CUDA_LIBS_PATH)
-  link_directories(${CUDA_LIBS_PATH})
-
-  set(CUDA_LIBRARIES_ABS ${CUDA_LIBRARIES})
-  ocv_convert_to_lib_name(CUDA_LIBRARIES ${CUDA_LIBRARIES})
-  set(CUDA_npp_LIBRARY_ABS ${CUDA_npp_LIBRARY})
-  ocv_convert_to_lib_name(CUDA_npp_LIBRARY ${CUDA_npp_LIBRARY})
-  if(HAVE_CUBLAS)
-    set(CUDA_cublas_LIBRARY_ABS ${CUDA_cublas_LIBRARY})
-    ocv_convert_to_lib_name(CUDA_cublas_LIBRARY ${CUDA_cublas_LIBRARY})
-  endif()
-
-  if(HAVE_CUFFT)
-    set(CUDA_cufft_LIBRARY_ABS ${CUDA_cufft_LIBRARY})
-    ocv_convert_to_lib_name(CUDA_cufft_LIBRARY ${CUDA_cufft_LIBRARY})
-  endif()
-endif()
@@ -81,39 +81,24 @@ if(PYTHON_EXECUTABLE)
    SET(PYTHON_PACKAGES_PATH "${_PYTHON_PACKAGES_PATH}" CACHE PATH "Where to install the python packages.")

    if(NOT PYTHON_NUMPY_INCLUDE_DIR)
-      if(CMAKE_CROSSCOMPILING)
-        message(STATUS "Cannot probe for Python/Numpy support (because we are cross-compiling OpenCV)")
-        message(STATUS "If you want to enable Python/Numpy support, set the following variables:")
-        message(STATUS "  PYTHON_INCLUDE_PATH")
-        message(STATUS "  PYTHON_LIBRARIES")
-        message(STATUS "  PYTHON_NUMPY_INCLUDE_DIR")
-      else()
-        # Attempt to discover the NumPy include directory. If this succeeds, then build python API with NumPy
-        execute_process(COMMAND ${PYTHON_EXECUTABLE} -c "import os; os.environ['DISTUTILS_USE_SDK']='1'; import numpy.distutils; print numpy.distutils.misc_util.get_numpy_include_dirs()[0]"
-                        RESULT_VARIABLE PYTHON_NUMPY_PROCESS
-                        OUTPUT_VARIABLE PYTHON_NUMPY_INCLUDE_DIR
-                        OUTPUT_STRIP_TRAILING_WHITESPACE)
+      # Attempt to discover the NumPy include directory. If this succeeds, then build python API with NumPy
+      execute_process(COMMAND ${PYTHON_EXECUTABLE} -c "import os; os.environ['DISTUTILS_USE_SDK']='1'; import numpy.distutils; print numpy.distutils.misc_util.get_numpy_include_dirs()[0]"
+                      RESULT_VARIABLE PYTHON_NUMPY_PROCESS
+                      OUTPUT_VARIABLE PYTHON_NUMPY_INCLUDE_DIR
+                      OUTPUT_STRIP_TRAILING_WHITESPACE)

-        if(NOT PYTHON_NUMPY_PROCESS EQUAL 0)
-          unset(PYTHON_NUMPY_INCLUDE_DIR)
-        endif()
+      if(PYTHON_NUMPY_PROCESS EQUAL 0)
+        file(TO_CMAKE_PATH "${PYTHON_NUMPY_INCLUDE_DIR}" _PYTHON_NUMPY_INCLUDE_DIR)
+        set(PYTHON_NUMPY_INCLUDE_DIR ${_PYTHON_NUMPY_INCLUDE_DIR} CACHE PATH "Path to numpy headers")
      endif()
    endif()

    if(PYTHON_NUMPY_INCLUDE_DIR)
-      file(TO_CMAKE_PATH "${PYTHON_NUMPY_INCLUDE_DIR}" _PYTHON_NUMPY_INCLUDE_DIR)
-      set(PYTHON_NUMPY_INCLUDE_DIR ${_PYTHON_NUMPY_INCLUDE_DIR} CACHE PATH "Path to numpy headers")
      set(PYTHON_USE_NUMPY TRUE)
-      if(CMAKE_CROSSCOMPILING)
-        if(NOT PYTHON_NUMPY_VERSION)
-          set(PYTHON_NUMPY_VERSION "undefined - cannot be probed because of the cross-compilation")
-        endif()
-      else()
-        execute_process(COMMAND ${PYTHON_EXECUTABLE} -c "import numpy; print numpy.version.version"
+      execute_process(COMMAND ${PYTHON_EXECUTABLE} -c "import numpy; print numpy.version.version"
                        RESULT_VARIABLE PYTHON_NUMPY_PROCESS
                        OUTPUT_VARIABLE PYTHON_NUMPY_VERSION
                        OUTPUT_STRIP_TRAILING_WHITESPACE)
-      endif()
    endif()
  endif(NOT ANDROID AND NOT IOS)

@@ -1,53 +0,0 @@
-if(NOT WITH_VTK OR ANDROID OR IOS)
-  return()
-endif()
-
-# VTK 6.x components
-find_package(VTK QUIET COMPONENTS vtkRenderingOpenGL vtkInteractionStyle vtkRenderingLOD vtkIOPLY vtkFiltersTexture vtkRenderingFreeType vtkIOExport NO_MODULE)
-
-# VTK 5.x components
-if(NOT VTK_FOUND)
-  find_package(VTK QUIET COMPONENTS vtkCommon NO_MODULE)
-endif()
-
-if(NOT VTK_FOUND)
-  set(HAVE_VTK OFF)
-  message(STATUS "VTK is not found. Please set -DVTK_DIR in CMake to VTK build directory, or to VTK install subdirectory with VTKConfig.cmake file")
-  return()
-endif()
-
-# Don't support ealier VTKs
-if(${VTK_VERSION} VERSION_LESS "5.8.0")
-  message(STATUS "VTK support is disabled. VTK ver. 5.8.0 is minimum required, but found VTK ver. ${VTK_VERSION}")
-  return()
-endif()
-
-# Different Qt versions can't be linked together
-if(HAVE_QT5 AND ${VTK_VERSION} VERSION_LESS "6.0.0")
-  if(VTK_USE_QT)
-    message(STATUS "VTK support is disabled. Incompatible combination: OpenCV + Qt5 and VTK ver.${VTK_VERSION} + Qt4")
-  endif()
-endif()
-
-# Different Qt versions can't be linked together. VTK 6.0.0 doesn't provide a way to get Qt version it was linked with
-if(HAVE_QT5 AND ${VTK_VERSION} VERSION_EQUAL "6.0.0" AND NOT DEFINED FORCE_VTK)
-  message(STATUS "VTK support is disabled. Possible incompatible combination: OpenCV+Qt5, and VTK ver.${VTK_VERSION} with Qt4")
-  message(STATUS "If it is known that VTK was compiled without Qt4, please define '-DFORCE_VTK=TRUE' flag in CMake")
-  return()
-endif()
-
-# Different Qt versions can't be linked together
-if(HAVE_QT AND ${VTK_VERSION} VERSION_GREATER "6.0.0" AND NOT ${VTK_QT_VERSION} STREQUAL "")
-  if(HAVE_QT5 AND ${VTK_QT_VERSION} EQUAL "4")
-    message(STATUS "VTK support is disabled. Incompatible combination: OpenCV + Qt5 and VTK ver.${VTK_VERSION} + Qt4")
-    return()
-  endif()
-
-  if(NOT HAVE_QT5 AND ${VTK_QT_VERSION} EQUAL "5")
-    message(STATUS "VTK support is disabled. Incompatible combination: OpenCV + Qt4 and VTK ver.${VTK_VERSION} + Qt5")
-    return()
-  endif()
-endif()
-
-set(HAVE_VTK ON)
-message(STATUS "Found VTK ver. ${VTK_VERSION} (usefile: ${VTK_USE_FILE})")
@@ -4,7 +4,7 @@
 CONFIGURE_FILE(
  "${OpenCV_SOURCE_DIR}/cmake/templates/cmake_uninstall.cmake.in"
  "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake"
-  @ONLY)
+  IMMEDIATE @ONLY)

 ADD_CUSTOM_TARGET(uninstall "${CMAKE_COMMAND}" -P "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake")
 if(ENABLE_SOLUTION_FOLDERS)
@@ -163,16 +163,9 @@ function(set_ipp_new_libraries _LATEST_VERSION)
        ${IPP_LIB_PREFIX}${IPP_PREFIX}${IPPCV}${IPP_SUFFIX}${IPP_LIB_SUFFIX}
        ${IPP_LIB_PREFIX}${IPP_PREFIX}${IPPI}${IPP_SUFFIX}${IPP_LIB_SUFFIX}
        ${IPP_LIB_PREFIX}${IPP_PREFIX}${IPPS}${IPP_SUFFIX}${IPP_LIB_SUFFIX}
-        ${IPP_LIB_PREFIX}${IPP_PREFIX}${IPPCORE}${IPP_SUFFIX}${IPP_LIB_SUFFIX})
+        ${IPP_LIB_PREFIX}${IPP_PREFIX}${IPPCORE}${IPP_SUFFIX}${IPP_LIB_SUFFIX}
+        PARENT_SCOPE)

-    if (UNIX)
-        set(IPP_LIBRARIES
-            ${IPP_LIBRARIES}
-            ${IPP_LIB_PREFIX}irc${CMAKE_SHARED_LIBRARY_SUFFIX}
-            ${IPP_LIB_PREFIX}imf${CMAKE_SHARED_LIBRARY_SUFFIX}
-            ${IPP_LIB_PREFIX}svml${CMAKE_SHARED_LIBRARY_SUFFIX})
-    endif()
-    set(IPP_LIBRARIES ${IPP_LIBRARIES} PARENT_SCOPE)
    return()

 endfunction()
@@ -215,39 +208,19 @@ function(set_ipp_variables _LATEST_VERSION)
        set(IPP_INCLUDE_DIRS ${IPP_ROOT_DIR}/include PARENT_SCOPE)

        if (APPLE)
-            set(IPP_LIBRARY_DIRS ${IPP_ROOT_DIR}/lib)
+            set(IPP_LIBRARY_DIRS ${IPP_ROOT_DIR}/lib PARENT_SCOPE)
        elseif (IPP_X64)
            if(NOT EXISTS ${IPP_ROOT_DIR}/lib/intel64)
                message(SEND_ERROR "IPP EM64T libraries not found")
            endif()
-            set(IPP_LIBRARY_DIRS ${IPP_ROOT_DIR}/lib/intel64)
+            set(IPP_LIBRARY_DIRS ${IPP_ROOT_DIR}/lib/intel64 PARENT_SCOPE)
        else()
            if(NOT EXISTS ${IPP_ROOT_DIR}/lib/ia32)
                message(SEND_ERROR "IPP IA32 libraries not found")
            endif()
-            set(IPP_LIBRARY_DIRS ${IPP_ROOT_DIR}/lib/ia32)
+            set(IPP_LIBRARY_DIRS ${IPP_ROOT_DIR}/lib/ia32 PARENT_SCOPE)
        endif()

-        if (UNIX)
-            get_filename_component(INTEL_COMPILER_LIBRARY_DIR ${IPP_ROOT_DIR}/../lib REALPATH)
-            if (IPP_X64)
-                if(NOT EXISTS ${INTEL_COMPILER_LIBRARY_DIR}/intel64)
-                    message(SEND_ERROR "Intel compiler EM64T libraries not found")
-                endif()
-                set(IPP_LIBRARY_DIRS
-                    ${IPP_LIBRARY_DIRS}
-                    ${INTEL_COMPILER_LIBRARY_DIR}/intel64)
-            else()
-                if(NOT EXISTS ${INTEL_COMPILER_LIBRARY_DIR}/ia32)
-                    message(SEND_ERROR "Intel compiler IA32 libraries not found")
-                endif()
-                set(IPP_LIBRARY_DIRS
-                    ${IPP_LIBRARY_DIRS}
-                    ${INTEL_COMPILER_LIBRARY_DIR}/ia32)
-            endif()
-        endif()
-        set(IPP_LIBRARY_DIRS ${IPP_LIBRARY_DIRS} PARENT_SCOPE)
-
        # set IPP_LIBRARIES variable (7.x or 8.x lib names)
        set_ipp_new_libraries(${_LATEST_VERSION})
        set(IPP_LIBRARIES ${IPP_LIBRARIES} PARENT_SCOPE)
@@ -56,11 +56,8 @@ if(ANDROID)

  # remove CUDA runtime and NPP from regular deps
  # it can be added separately if needed.
-  ocv_list_filterout(OPENCV_EXTRA_COMPONENTS_CONFIGMAKE "cusparse")
-  ocv_list_filterout(OPENCV_EXTRA_COMPONENTS_CONFIGMAKE "cufft")
-  ocv_list_filterout(OPENCV_EXTRA_COMPONENTS_CONFIGMAKE "cublas")
-  ocv_list_filterout(OPENCV_EXTRA_COMPONENTS_CONFIGMAKE "npp")
-  ocv_list_filterout(OPENCV_EXTRA_COMPONENTS_CONFIGMAKE "cudart")
+  ocv_list_filterout(OPENCV_EXTRA_COMPONENTS_CONFIGMAKE "libcu")
+  ocv_list_filterout(OPENCV_EXTRA_COMPONENTS_CONFIGMAKE "libnpp")

  if(HAVE_CUDA)
    # CUDA runtime libraries and are required always
@@ -131,7 +128,7 @@ if(ANDROID)
  set(OPENCV_LIBS_DIR_CONFIGCMAKE "\$(OPENCV_THIS_DIR)/lib/\$(OPENCV_TARGET_ARCH_ABI)")
  set(OPENCV_3RDPARTY_LIBS_DIR_CONFIGCMAKE "\$(OPENCV_THIS_DIR)/3rdparty/lib/\$(OPENCV_TARGET_ARCH_ABI)")

-  configure_file("${OpenCV_SOURCE_DIR}/cmake/templates/OpenCV.mk.in" "${CMAKE_BINARY_DIR}/OpenCV.mk" @ONLY)
+  configure_file("${OpenCV_SOURCE_DIR}/cmake/templates/OpenCV.mk.in" "${CMAKE_BINARY_DIR}/OpenCV.mk" IMMEDIATE @ONLY)

  # -------------------------------------------------------------------------------------------
  #  Part 2/2: ${BIN_DIR}/unix-install/OpenCV.mk -> For use with "make install"
@@ -141,6 +138,6 @@ if(ANDROID)
  set(OPENCV_LIBS_DIR_CONFIGCMAKE "\$(OPENCV_THIS_DIR)/../libs/\$(OPENCV_TARGET_ARCH_ABI)")
  set(OPENCV_3RDPARTY_LIBS_DIR_CONFIGCMAKE "\$(OPENCV_THIS_DIR)/../3rdparty/libs/\$(OPENCV_TARGET_ARCH_ABI)")

-  configure_file("${OpenCV_SOURCE_DIR}/cmake/templates/OpenCV.mk.in" "${CMAKE_BINARY_DIR}/unix-install/OpenCV.mk" @ONLY)
+  configure_file("${OpenCV_SOURCE_DIR}/cmake/templates/OpenCV.mk.in" "${CMAKE_BINARY_DIR}/unix-install/OpenCV.mk" IMMEDIATE @ONLY)
  install(FILES ${CMAKE_BINARY_DIR}/unix-install/OpenCV.mk DESTINATION ${OPENCV_CONFIG_INSTALL_PATH} COMPONENT dev)
 endif(ANDROID)
@@ -83,9 +83,9 @@ endif()

 export(TARGETS ${OpenCVModules_TARGETS} FILE "${CMAKE_BINARY_DIR}/OpenCVModules${modules_file_suffix}.cmake")

-configure_file("${OpenCV_SOURCE_DIR}/cmake/templates/OpenCVConfig.cmake.in" "${CMAKE_BINARY_DIR}/OpenCVConfig.cmake" @ONLY)
+configure_file("${OpenCV_SOURCE_DIR}/cmake/templates/OpenCVConfig.cmake.in" "${CMAKE_BINARY_DIR}/OpenCVConfig.cmake" IMMEDIATE @ONLY)
 #support for version checking when finding opencv. find_package(OpenCV 2.3.1 EXACT) should now work.
-configure_file("${OpenCV_SOURCE_DIR}/cmake/templates/OpenCVConfig-version.cmake.in" "${CMAKE_BINARY_DIR}/OpenCVConfig-version.cmake" @ONLY)
+configure_file("${OpenCV_SOURCE_DIR}/cmake/templates/OpenCVConfig-version.cmake.in" "${CMAKE_BINARY_DIR}/OpenCVConfig-version.cmake" IMMEDIATE @ONLY)

 # --------------------------------------------------------------------------------------------
 #  Part 2/3: ${BIN_DIR}/unix-install/OpenCVConfig.cmake -> For use *with* "make install"
@@ -98,8 +98,8 @@ if(INSTALL_TO_MANGLED_PATHS)
  set(OpenCV_3RDPARTY_LIB_DIRS_CONFIGCMAKE "\"\${OpenCV_INSTALL_PATH}/${OpenCV_3RDPARTY_LIB_DIRS_CONFIGCMAKE}\"")
 endif()

-configure_file("${OpenCV_SOURCE_DIR}/cmake/templates/OpenCVConfig.cmake.in" "${CMAKE_BINARY_DIR}/unix-install/OpenCVConfig.cmake" @ONLY)
-configure_file("${OpenCV_SOURCE_DIR}/cmake/templates/OpenCVConfig-version.cmake.in" "${CMAKE_BINARY_DIR}/unix-install/OpenCVConfig-version.cmake" @ONLY)
+configure_file("${OpenCV_SOURCE_DIR}/cmake/templates/OpenCVConfig.cmake.in" "${CMAKE_BINARY_DIR}/unix-install/OpenCVConfig.cmake" IMMEDIATE @ONLY)
+configure_file("${OpenCV_SOURCE_DIR}/cmake/templates/OpenCVConfig-version.cmake.in" "${CMAKE_BINARY_DIR}/unix-install/OpenCVConfig-version.cmake" IMMEDIATE @ONLY)

 if(UNIX) # ANDROID configuration is created here also
  #http://www.vtk.org/Wiki/CMake/Tutorials/Packaging reference
@@ -131,8 +131,8 @@ if(WIN32)
  set(OpenCV2_INCLUDE_DIRS_CONFIGCMAKE "\"\"")

  exec_program(mkdir ARGS "-p \"${CMAKE_BINARY_DIR}/win-install/\"" OUTPUT_VARIABLE RET_VAL)
-  configure_file("${OpenCV_SOURCE_DIR}/cmake/templates/OpenCVConfig.cmake.in" "${CMAKE_BINARY_DIR}/win-install/OpenCVConfig.cmake" @ONLY)
-  configure_file("${OpenCV_SOURCE_DIR}/cmake/templates/OpenCVConfig-version.cmake.in" "${CMAKE_BINARY_DIR}/win-install/OpenCVConfig-version.cmake" @ONLY)
+  configure_file("${OpenCV_SOURCE_DIR}/cmake/templates/OpenCVConfig.cmake.in" "${CMAKE_BINARY_DIR}/win-install/OpenCVConfig.cmake" IMMEDIATE @ONLY)
+  configure_file("${OpenCV_SOURCE_DIR}/cmake/templates/OpenCVConfig-version.cmake.in" "${CMAKE_BINARY_DIR}/win-install/OpenCVConfig-version.cmake" IMMEDIATE @ONLY)
  if(BUILD_SHARED_LIBS)
    install(FILES "${CMAKE_BINARY_DIR}/win-install/OpenCVConfig.cmake" DESTINATION "${OpenCV_INSTALL_BINARIES_PREFIX}lib" COMPONENT dev)
    install(EXPORT OpenCVModules DESTINATION "${OpenCV_INSTALL_BINARIES_PREFIX}lib" FILE OpenCVModules${modules_file_suffix}.cmake COMPONENT dev)
@@ -78,7 +78,7 @@ else()
 endif()
 configure_file("${OpenCV_SOURCE_DIR}/cmake/templates/opencv-XXX.pc.in"
               "${CMAKE_BINARY_DIR}/unix-install/${OPENCV_PC_FILE_NAME}"
-               @ONLY)
+               @ONLY IMMEDIATE)

 if(UNIX AND NOT ANDROID)
  install(FILES ${CMAKE_BINARY_DIR}/unix-install/${OPENCV_PC_FILE_NAME} DESTINATION ${OPENCV_LIB_INSTALL_PATH}/pkgconfig COMPONENT dev)
@@ -27,8 +27,7 @@
 # The verbose template for OpenCV module:
 #
 #   ocv_add_module(modname <dependencies>)
-#   ocv_glob_module_sources(([EXCLUDE_CUDA] <extra sources&headers>)
-#                          or glob them manually and ocv_set_module_sources(...)
+#   ocv_glob_module_sources() or glob them manually and ocv_set_module_sources(...)
 #   ocv_module_include_directories(<extra include directories>)
 #   ocv_create_module()
 #   <add extra link dependencies, compiler options, etc>
@@ -136,13 +135,13 @@ macro(ocv_add_module _name)

    # parse list of dependencies
    if("${ARGV1}" STREQUAL "INTERNAL" OR "${ARGV1}" STREQUAL "BINDINGS")
-      set(OPENCV_MODULE_${the_module}_CLASS "${ARGV1}" CACHE INTERNAL "The category of the module")
+      set(OPENCV_MODULE_${the_module}_CLASS "${ARGV1}" CACHE INTERNAL "The cathegory of the module")
      set(__ocv_argn__ ${ARGN})
      list(REMOVE_AT __ocv_argn__ 0)
      ocv_add_dependencies(${the_module} ${__ocv_argn__})
      unset(__ocv_argn__)
    else()
-      set(OPENCV_MODULE_${the_module}_CLASS "PUBLIC" CACHE INTERNAL "The category of the module")
+      set(OPENCV_MODULE_${the_module}_CLASS "PUBLIC" CACHE INTERNAL "The cathegory of the module")
      ocv_add_dependencies(${the_module} ${ARGN})
      if(BUILD_${the_module})
        set(OPENCV_MODULES_PUBLIC ${OPENCV_MODULES_PUBLIC} "${the_module}" CACHE INTERNAL "List of OpenCV modules marked for export")
@@ -479,38 +478,22 @@ endmacro()

 # finds and sets headers and sources for the standard OpenCV module
 # Usage:
-# ocv_glob_module_sources([EXCLUDE_CUDA] <extra sources&headers in the same format as used in ocv_set_module_sources>)
+# ocv_glob_module_sources(<extra sources&headers in the same format as used in ocv_set_module_sources>)
 macro(ocv_glob_module_sources)
-  set(_argn ${ARGN})
-  list(FIND _argn "EXCLUDE_CUDA" exclude_cuda)
-  if(NOT exclude_cuda EQUAL -1)
-    list(REMOVE_AT _argn ${exclude_cuda})
-  endif()
-
  file(GLOB_RECURSE lib_srcs "src/*.cpp")
  file(GLOB_RECURSE lib_int_hdrs "src/*.hpp" "src/*.h")
  file(GLOB lib_hdrs "include/opencv2/${name}/*.hpp" "include/opencv2/${name}/*.h")
  file(GLOB lib_hdrs_detail "include/opencv2/${name}/detail/*.hpp" "include/opencv2/${name}/detail/*.h")
-  file(GLOB_RECURSE lib_srcs_apple "src/*.mm")
-  if (APPLE)
-    list(APPEND lib_srcs ${lib_srcs_apple})
-  endif()

-  if (exclude_cuda EQUAL -1)
-    file(GLOB lib_cuda_srcs "src/cuda/*.cu")
-    set(cuda_objs "")
-    set(lib_cuda_hdrs "")
-    if(HAVE_CUDA)
-      ocv_include_directories(${CUDA_INCLUDE_DIRS})
-      file(GLOB lib_cuda_hdrs "src/cuda/*.hpp")
+  file(GLOB lib_cuda_srcs "src/cuda/*.cu")
+  set(cuda_objs "")
+  set(lib_cuda_hdrs "")
+  if(HAVE_CUDA)
+    ocv_include_directories(${CUDA_INCLUDE_DIRS})
+    file(GLOB lib_cuda_hdrs "src/cuda/*.hpp")

-      ocv_cuda_compile(cuda_objs ${lib_cuda_srcs} ${lib_cuda_hdrs})
-      source_group("Src\\Cuda"      FILES ${lib_cuda_srcs} ${lib_cuda_hdrs})
-    endif()
-  else()
-    set(cuda_objs "")
-    set(lib_cuda_srcs "")
-    set(lib_cuda_hdrs "")
+    ocv_cuda_compile(cuda_objs ${lib_cuda_srcs} ${lib_cuda_hdrs})
+    source_group("Src\\Cuda"      FILES ${lib_cuda_srcs} ${lib_cuda_hdrs})
  endif()

  source_group("Src" FILES ${lib_srcs} ${lib_int_hdrs})
@@ -529,8 +512,8 @@ macro(ocv_glob_module_sources)
  source_group("Include" FILES ${lib_hdrs})
  source_group("Include\\detail" FILES ${lib_hdrs_detail})

-  ocv_set_module_sources(${_argn} HEADERS ${lib_hdrs} ${lib_hdrs_detail}
-                         SOURCES ${lib_srcs} ${lib_int_hdrs} ${cuda_objs} ${lib_cuda_srcs} ${lib_cuda_hdrs})
+  ocv_set_module_sources(${ARGN} HEADERS ${lib_hdrs} ${lib_hdrs_detail}
+                                 SOURCES ${lib_srcs} ${lib_int_hdrs} ${cuda_objs} ${lib_cuda_srcs} ${lib_cuda_hdrs})
 endmacro()

 # creates OpenCV module in current folder
@@ -629,20 +612,11 @@ endmacro()
 # short command for adding simple OpenCV module
 # see ocv_add_module for argument details
 # Usage:
-# ocv_define_module(module_name  [INTERNAL] [EXCLUDE_CUDA] [REQUIRED] [<list of dependencies>] [OPTIONAL <list of optional dependencies>])
+# ocv_define_module(module_name  [INTERNAL] [REQUIRED] [<list of dependencies>] [OPTIONAL <list of optional dependencies>])
 macro(ocv_define_module module_name)
-  set(_argn ${ARGN})
-  set(exclude_cuda "")
-  foreach(arg ${_argn})
-    if("${arg}" STREQUAL "EXCLUDE_CUDA")
-      set(exclude_cuda "${arg}")
-      list(REMOVE_ITEM _argn ${arg})
-    endif()
-  endforeach()
-
-  ocv_add_module(${module_name} ${_argn})
+  ocv_add_module(${module_name} ${ARGN})
  ocv_module_include_directories()
-  ocv_glob_module_sources(${exclude_cuda})
+  ocv_glob_module_sources()
  ocv_create_module()
  ocv_add_precompiled_headers(${the_module})

@@ -770,8 +744,8 @@ function(ocv_add_accuracy_tests)
      endif()

      get_native_precompiled_header(${the_target} test_precomp.hpp)
-      add_executable(${the_target} ${OPENCV_TEST_${the_module}_SOURCES} ${${the_target}_pch})

+      add_executable(${the_target} ${OPENCV_TEST_${the_module}_SOURCES} ${${the_target}_pch})
      target_link_libraries(${the_target} ${OPENCV_MODULE_${the_module}_DEPS} ${test_deps} ${OPENCV_LINKER_LIBS})
      add_dependencies(opencv_tests ${the_target})

@@ -1,6 +1,3 @@
-# Use patched version of CPACK to build accurate set of Debian packages
-# https://github.com/asmorkalov/CMake/tree/deb_generator_improvement
-
 if(EXISTS "${CMAKE_ROOT}/Modules/CPack.cmake")
 set(CPACK_set_DESTDIR "on")

@@ -21,8 +18,6 @@ OpenCV makes it easy for businesses to utilize and modify the code.")
  set(CPACK_PACKAGE_VERSION "${OPENCV_VCSVERSION}")
 endif(NOT OPENCV_CUSTOM_PACKAGE_INFO)

-set(CPACK_STRIP_FILES 1)
-
 #arch
 if(X86)
  set(CPACK_DEBIAN_ARCHITECTURE "i386")
@@ -73,53 +68,32 @@ set(CPACK_COMPONENT_tests_DEPENDS libs)

 if(HAVE_CUDA)
  string(REPLACE "." "-" cuda_version_suffix ${CUDA_VERSION})
-  if(CUDA_VERSION VERSION_LESS "6.5")
-    set(CPACK_DEB_libs_PACKAGE_DEPENDS "cuda-core-libs-${cuda_version_suffix}, cuda-extra-libs-${cuda_version_suffix}")
-    set(CPACK_DEB_dev_PACKAGE_DEPENDS "cuda-headers-${cuda_version_suffix}")
-  else()
-    set(CPACK_DEB_libs_PACKAGE_DEPENDS "cuda-cudart-${cuda_version_suffix}, cuda-npp-${cuda_version_suffix}")
-    set(CPACK_DEB_dev_PACKAGE_DEPENDS "cuda-cudart-dev-${cuda_version_suffix}, cuda-npp-dev-${cuda_version_suffix}")
-    if(HAVE_CUFFT)
-      set(CPACK_DEB_libs_PACKAGE_DEPENDS "${CPACK_DEB_libs_PACKAGE_DEPENDS}, cuda-cufft-${cuda_version_suffix}")
-      set(CPACK_DEB_dev_PACKAGE_DEPENDS "${CPACK_DEB_dev_PACKAGE_DEPENDS}, cuda-cufft-dev-${cuda_version_suffix}")
-    endif()
-    if(HAVE_HAVE_CUBLAS)
-      set(CPACK_DEB_libs_PACKAGE_DEPENDS "${CPACK_DEB_libs_PACKAGE_DEPENDS}, cuda-cublas-${cuda_version_suffix}")
-      set(CPACK_DEB_dev_PACKAGE_DEPENDS "${CPACK_DEB_dev_PACKAGE_DEPENDS}, cuda-cublas-dev-${cuda_version_suffix}")
-    endif()
-  endif()
-
+  set(CPACK_DEB_libs_PACKAGE_DEPENDS "cuda-core-libs-${cuda_version_suffix}, cuda-extra-libs-${cuda_version_suffix}")
  set(CPACK_COMPONENT_dev_DEPENDS libs)
+  set(CPACK_DEB_dev_PACKAGE_DEPENDS "cuda-headers-${cuda_version_suffix}")
 endif()

 if(NOT OPENCV_CUSTOM_PACKAGE_INFO)
  set(CPACK_COMPONENT_libs_DISPLAY_NAME "lib${CMAKE_PROJECT_NAME}")
  set(CPACK_COMPONENT_libs_DESCRIPTION "Open Computer Vision Library")
-  set(CPACK_COMPONENT_libs_SECTION "libs")

  set(CPACK_COMPONENT_python_DISPLAY_NAME "lib${CMAKE_PROJECT_NAME}-python")
  set(CPACK_COMPONENT_python_DESCRIPTION "Python bindings for Open Source Computer Vision Library")
-  set(CPACK_COMPONENT_python_SECTION "python")

  set(CPACK_COMPONENT_java_DISPLAY_NAME "lib${CMAKE_PROJECT_NAME}-java")
  set(CPACK_COMPONENT_java_DESCRIPTION "Java bindings for Open Source Computer Vision Library")
-  set(CPACK_COMPONENT_java_SECTION "java")

  set(CPACK_COMPONENT_dev_DISPLAY_NAME "lib${CMAKE_PROJECT_NAME}-dev")
  set(CPACK_COMPONENT_dev_DESCRIPTION "Development files for Open Source Computer Vision Library")
-  set(CPACK_COMPONENT_dev_SECTION "libdevel")

  set(CPACK_COMPONENT_docs_DISPLAY_NAME "lib${CMAKE_PROJECT_NAME}-docs")
  set(CPACK_COMPONENT_docs_DESCRIPTION "Documentation for Open Source Computer Vision Library")
-  set(CPACK_COMPONENT_docs_SECTION "doc")

  set(CPACK_COMPONENT_samples_DISPLAY_NAME "lib${CMAKE_PROJECT_NAME}-samples")
  set(CPACK_COMPONENT_samples_DESCRIPTION "Samples for Open Source Computer Vision Library")
-  set(CPACK_COMPONENT_samples_SECTION "devel")

  set(CPACK_COMPONENT_tests_DISPLAY_NAME "lib${CMAKE_PROJECT_NAME}-tests")
  set(CPACK_COMPONENT_tests_DESCRIPTION "Accuracy and performance tests for Open Source Computer Vision Library")
-  set(CPACK_COMPONENT_tests_SECTION "misc")
 endif(NOT OPENCV_CUSTOM_PACKAGE_INFO)

 if(NOT OPENCV_CUSTOM_PACKAGE_LAYOUT)
@@ -152,14 +152,11 @@ ifeq ($(OPENCV_MK_$(OPENCV_TARGET_ARCH_ABI)_ALREADY_INCLUDED),)
    OPENCV_MK_$(OPENCV_TARGET_ARCH_ABI)_ALREADY_INCLUDED:=on
 endif

-ifeq ($(OPENCV_MK_$(OPENCV_TARGET_ARCH_ABI)_GPU_ALREADY_INCLUDED),)
-    ifeq ($(OPENCV_USE_GPU_MODULE),on)
-        include $(CLEAR_VARS)
-        LOCAL_MODULE:=opencv_gpu
-        LOCAL_SRC_FILES:=$(OPENCV_LIBS_DIR)/libopencv_gpu.a
-        include $(PREBUILT_STATIC_LIBRARY)
-    endif
-    OPENCV_MK_$(OPENCV_TARGET_ARCH_ABI)_GPU_ALREADY_INCLUDED:=on
+ifeq ($(OPENCV_USE_GPU_MODULE),on)
+    include $(CLEAR_VARS)
+    LOCAL_MODULE:=opencv_gpu
+    LOCAL_SRC_FILES:=$(OPENCV_LIBS_DIR)/libopencv_gpu.a
+    include $(PREBUILT_STATIC_LIBRARY)
 endif

 ifeq ($(OPENCV_LOCAL_CFLAGS),)
@@ -18,8 +18,8 @@
 #    This file will define the following variables:
 #      - OpenCV_LIBS                     : The list of all imported targets for OpenCV modules.
 #      - OpenCV_INCLUDE_DIRS             : The OpenCV include directories.
-#      - OpenCV_COMPUTE_CAPABILITIES     : The version of compute capability.
-#      - OpenCV_ANDROID_NATIVE_API_LEVEL : Minimum required level of Android API.
+#      - OpenCV_COMPUTE_CAPABILITIES     : The version of compute capability
+#      - OpenCV_ANDROID_NATIVE_API_LEVEL : Minimum required level of Android API
 #      - OpenCV_VERSION                  : The version of this OpenCV build: "@OPENCV_VERSION@"
 #      - OpenCV_VERSION_MAJOR            : Major version part of OpenCV_VERSION: "@OPENCV_VERSION_MAJOR@"
 #      - OpenCV_VERSION_MINOR            : Minor version part of OpenCV_VERSION: "@OPENCV_VERSION_MINOR@"
@@ -27,26 +27,22 @@
 #      - OpenCV_VERSION_TWEAK            : Tweak version part of OpenCV_VERSION: "@OPENCV_VERSION_TWEAK@"
 #
 #    Advanced variables:
-#      - OpenCV_SHARED                   : Use OpenCV as shared library
-#      - OpenCV_CONFIG_PATH              : Path to this OpenCVConfig.cmake
-#      - OpenCV_INSTALL_PATH             : OpenCV location (not set on Windows)
-#      - OpenCV_LIB_COMPONENTS           : Present OpenCV modules list
-#      - OpenCV_USE_MANGLED_PATHS        : Mangled OpenCV path flag
-#      - OpenCV_MODULES_SUFFIX           : The suffix for OpenCVModules-XXX.cmake file
-#      - OpenCV_HAVE_ANDROID_CAMERA      : Presence of Android native camera wrappers
+#      - OpenCV_SHARED
+#      - OpenCV_CONFIG_PATH
+#      - OpenCV_INSTALL_PATH  (not set on Windows)
+#      - OpenCV_LIB_COMPONENTS
+#      - OpenCV_USE_MANGLED_PATHS
+#      - OpenCV_HAVE_ANDROID_CAMERA
 #
 # ===================================================================================

-if(NOT DEFINED OpenCV_MODULES_SUFFIX)
-  if(ANDROID)
-    string(REPLACE - _ OpenCV_MODULES_SUFFIX "_${ANDROID_NDK_ABI_NAME}")
-  else()
-    set(OpenCV_MODULES_SUFFIX "")
-  endif()
+set(modules_file_suffix "")
+if(ANDROID)
+  string(REPLACE - _ modules_file_suffix "_${ANDROID_NDK_ABI_NAME}")
 endif()

 if(NOT TARGET opencv_core)
-  include(${CMAKE_CURRENT_LIST_DIR}/OpenCVModules${OpenCV_MODULES_SUFFIX}.cmake)
+  include(${CMAKE_CURRENT_LIST_DIR}/OpenCVModules${modules_file_suffix}.cmake)
 endif()

 # TODO All things below should be reviewed. What is about of moving this code into related modules (special vars/hooks/files)
@@ -60,11 +56,7 @@ set(OpenCV_USE_CUFFT    @HAVE_CUFFT@)
 set(OpenCV_USE_NVCUVID  @HAVE_NVCUVID@)

 # Android API level from which OpenCV has been compiled is remembered
-if(ANDROID)
-  set(OpenCV_ANDROID_NATIVE_API_LEVEL @OpenCV_ANDROID_NATIVE_API_LEVEL_CONFIGCMAKE@)
-else()
-  set(OpenCV_ANDROID_NATIVE_API_LEVEL 0)
-endif()
+set(OpenCV_ANDROID_NATIVE_API_LEVEL @OpenCV_ANDROID_NATIVE_API_LEVEL_CONFIGCMAKE@)

 # Some additional settings are required if OpenCV is built as static libs
 set(OpenCV_SHARED @BUILD_SHARED_LIBS@)
@@ -75,8 +67,8 @@ set(OpenCV_USE_MANGLED_PATHS @OpenCV_USE_MANGLED_PATHS_CONFIGCMAKE@)
 # Extract the directory where *this* file has been installed (determined at cmake run-time)
 get_filename_component(OpenCV_CONFIG_PATH "${CMAKE_CURRENT_LIST_FILE}" PATH CACHE)

-if(NOT WIN32 OR ANDROID)
-  if(ANDROID)
+if(NOT WIN32 OR OpenCV_ANDROID_NATIVE_API_LEVEL GREATER 0)
+  if(OpenCV_ANDROID_NATIVE_API_LEVEL GREATER 0)
    set(OpenCV_INSTALL_PATH "${OpenCV_CONFIG_PATH}/../../..")
  else()
    set(OpenCV_INSTALL_PATH "${OpenCV_CONFIG_PATH}/../..")
@@ -214,7 +206,7 @@ foreach(__opttype OPT DBG)
  SET(OpenCV_EXTRA_LIBS_${__opttype} "")

  # CUDA
-  if(OpenCV_CUDA_VERSION)
+  if(OpenCV_CUDA_VERSION AND (CMAKE_CROSSCOMPILING OR (WIN32 AND NOT OpenCV_SHARED)))
    if(NOT CUDA_FOUND)
      find_package(CUDA ${OpenCV_CUDA_VERSION} EXACT REQUIRED)
    else()
@@ -223,41 +215,32 @@ foreach(__opttype OPT DBG)
      endif()
    endif()

-    set(OpenCV_CUDA_LIBS_ABSPATH ${CUDA_LIBRARIES})
+    list(APPEND OpenCV_EXTRA_LIBS_${__opttype} ${CUDA_LIBRARIES})

    if(${CUDA_VERSION} VERSION_LESS "5.5")
-      list(APPEND OpenCV_CUDA_LIBS_ABSPATH ${CUDA_npp_LIBRARY})
+      list(APPEND OpenCV_EXTRA_LIBS_${__opttype} ${CUDA_npp_LIBRARY})
    else()
      find_cuda_helper_libs(nppc)
      find_cuda_helper_libs(nppi)
      find_cuda_helper_libs(npps)
-      list(APPEND OpenCV_CUDA_LIBS_ABSPATH ${CUDA_nppc_LIBRARY} ${CUDA_nppi_LIBRARY} ${CUDA_npps_LIBRARY})
+      list(APPEND OpenCV_EXTRA_LIBS_${__opttype} ${CUDA_nppc_LIBRARY} ${CUDA_nppi_LIBRARY} ${CUDA_npps_LIBRARY})
    endif()

    if(OpenCV_USE_CUBLAS)
-      list(APPEND OpenCV_CUDA_LIBS_ABSPATH ${CUDA_CUBLAS_LIBRARIES})
+      list(APPEND OpenCV_EXTRA_LIBS_${__opttype} ${CUDA_CUBLAS_LIBRARIES})
    endif()

    if(OpenCV_USE_CUFFT)
-      list(APPEND OpenCV_CUDA_LIBS_ABSPATH ${CUDA_CUFFT_LIBRARIES})
+      list(APPEND OpenCV_EXTRA_LIBS_${__opttype} ${CUDA_CUFFT_LIBRARIES})
    endif()

    if(OpenCV_USE_NVCUVID)
-      list(APPEND OpenCV_CUDA_LIBS_ABSPATH ${CUDA_nvcuvid_LIBRARIES})
+      list(APPEND OpenCV_EXTRA_LIBS_${__opttype} ${CUDA_nvcuvid_LIBRARIES})
    endif()

    if(WIN32)
-      list(APPEND OpenCV_CUDA_LIBS_ABSPATH ${CUDA_nvcuvenc_LIBRARIES})
+      list(APPEND OpenCV_EXTRA_LIBS_${__opttype} ${CUDA_nvcuvenc_LIBRARIES})
    endif()
-
-    set(OpenCV_CUDA_LIBS_RELPATH "")
-    foreach(l ${OpenCV_CUDA_LIBS_ABSPATH})
-      get_filename_component(_tmp ${l} PATH)
-      list(APPEND OpenCV_CUDA_LIBS_RELPATH ${_tmp})
-    endforeach()
-
-    list(REMOVE_DUPLICATES OpenCV_CUDA_LIBS_RELPATH)
-    link_directories(${OpenCV_CUDA_LIBS_RELPATH})
  endif()
 endforeach()

@@ -161,6 +161,6 @@
 /* Xine video library */
 #cmakedefine HAVE_XINE

-/* Define if your processor stores words with the most significant byte
+/* Define to 1 if your processor stores words with the most significant byte
   first (like Motorola and SPARC, unlike Intel and VAX). */
 #cmakedefine WORDS_BIGENDIAN
@@ -44,7 +44,7 @@ master_doc = 'index'

 # General information about the project.
 project = u'OpenCV'
-copyright = u'2011-2014, opencv dev team'
+copyright = u'2011-2013, opencv dev team'

 # The version info for the project you're documenting, acts as replacement for
 # |version| and |release|, also used in various other places throughout the
@@ -293,11 +293,11 @@ extlinks = {
            'oldbasicstructures' : ('http://docs.opencv.org/modules/core/doc/old_basic_structures.html#%s', None),
            'readwriteimagevideo' : ('http://docs.opencv.org/modules/highgui/doc/reading_and_writing_images_and_video.html#%s', None),
            'operationsonarrays' : ('http://docs.opencv.org/modules/core/doc/operations_on_arrays.html#%s', None),
-            'utilitysystemfunctions' : ('http://docs.opencv.org/modules/core/doc/utility_and_system_functions_and_macros.html#%s', None),
-            'imgprocfilter' : ('http://docs.opencv.org/modules/imgproc/doc/filtering.html#%s', None),
-            'svms' : ('http://docs.opencv.org/modules/ml/doc/support_vector_machines.html#%s', None),
-            'drawingfunc' : ('http://docs.opencv.org/modules/core/doc/drawing_functions.html#%s', None),
-            'xmlymlpers' : ('http://docs.opencv.org/modules/core/doc/xml_yaml_persistence.html#%s', None),
+            'utilitysystemfunctions':('http://docs.opencv.org/modules/core/doc/utility_and_system_functions_and_macros.html#%s', None),
+            'imgprocfilter':('http://docs.opencv.org/modules/imgproc/doc/filtering.html#%s', None),
+            'svms':('http://docs.opencv.org/modules/ml/doc/support_vector_machines.html#%s', None),
+            'drawingfunc':('http://docs.opencv.org/modules/core/doc/drawing_functions.html#%s', None),
+            'xmlymlpers':('http://docs.opencv.org/modules/core/doc/xml_yaml_persistence.html#%s', None),
            'hgvideo' : ('http://docs.opencv.org/modules/highgui/doc/reading_and_writing_images_and_video.html#%s', None),
            'gpuinit' : ('http://docs.opencv.org/modules/gpu/doc/initalization_and_information.html#%s', None),
            'gpudatastructure' : ('http://docs.opencv.org/modules/gpu/doc/data_structures.html#%s', None),
@@ -305,58 +305,56 @@ extlinks = {
            'gpuperelement' : ('http://docs.opencv.org/modules/gpu/doc/per_element_operations.html#%s', None),
            'gpuimgproc' : ('http://docs.opencv.org/modules/gpu/doc/image_processing.html#%s', None),
            'gpumatrixreduct' : ('http://docs.opencv.org/modules/gpu/doc/matrix_reductions.html#%s', None),
-            'filtering' : ('http://docs.opencv.org/modules/imgproc/doc/filtering.html#%s', None),
+            'filtering':('http://docs.opencv.org/modules/imgproc/doc/filtering.html#%s', None),
            'flann' : ('http://docs.opencv.org/modules/flann/doc/flann_fast_approximate_nearest_neighbor_search.html#%s', None ),
            'calib3d' : ('http://docs.opencv.org/modules/calib3d/doc/camera_calibration_and_3d_reconstruction.html#%s', None ),
            'feature2d' : ('http://docs.opencv.org/modules/imgproc/doc/feature_detection.html#%s', None ),
            'imgproc_geometric' : ('http://docs.opencv.org/modules/imgproc/doc/geometric_transformations.html#%s', None ),
-            'miscellaneous_transformations' : ('http://docs.opencv.org/modules/imgproc/doc/miscellaneous_transformations.html#%s', None),
-            'user_interface' : ('http://docs.opencv.org/modules/highgui/doc/user_interface.html#%s', None),

            # 'opencv_group' : ('http://answers.opencv.org/%s', None),
            'opencv_qa' : ('http://answers.opencv.org/%s', None),
            'how_to_contribute' : ('http://code.opencv.org/projects/opencv/wiki/How_to_contribute/%s', None),

-            'cvt_color' : ('http://docs.opencv.org/modules/imgproc/doc/miscellaneous_transformations.html?highlight=cvtcolor#cvtcolor%s', None),
-            'imread' : ('http://docs.opencv.org/modules/highgui/doc/reading_and_writing_images_and_video.html?highlight=imread#imread%s', None),
-            'imwrite' : ('http://docs.opencv.org/modules/highgui/doc/reading_and_writing_images_and_video.html?highlight=imwrite#imwrite%s', None),
-            'imshow' : ('http://docs.opencv.org/modules/highgui/doc/user_interface.html?highlight=imshow#imshow%s', None),
-            'named_window' : ('http://docs.opencv.org/modules/highgui/doc/user_interface.html?highlight=namedwindow#namedwindow%s', None),
-            'wait_key' : ('http://docs.opencv.org/modules/highgui/doc/user_interface.html?highlight=waitkey#waitkey%s', None),
-            'add_weighted' : ('http://docs.opencv.org/modules/core/doc/operations_on_arrays.html?highlight=addweighted#addweighted%s', None),
-            'saturate_cast' : ('http://docs.opencv.org/modules/core/doc/utility_and_system_functions_and_macros.html?highlight=saturate_cast#saturate-cast%s', None),
-            'mat_zeros' : ('http://docs.opencv.org/modules/core/doc/basic_structures.html?highlight=zeros#mat-zeros%s', None),
-            'convert_to' : ('http://docs.opencv.org/modules/core/doc/basic_structures.html#mat-convertto%s', None),
-            'create_trackbar' : ('http://docs.opencv.org/modules/highgui/doc/user_interface.html?highlight=createtrackbar#createtrackbar%s', None),
-            'point' : ('http://docs.opencv.org/modules/core/doc/basic_structures.html#point%s', None),
-            'scalar' : ('http://docs.opencv.org/modules/core/doc/basic_structures.html#scalar%s', None),
-            'line' : ('http://docs.opencv.org/modules/core/doc/drawing_functions.html#line%s', None),
-            'ellipse' : ('http://docs.opencv.org/modules/core/doc/drawing_functions.html#ellipse%s', None),
-            'rectangle' : ('http://docs.opencv.org/modules/core/doc/drawing_functions.html#rectangle%s', None),
-            'circle' : ('http://docs.opencv.org/modules/core/doc/drawing_functions.html#circle%s', None),
-            'fill_poly' : ('http://docs.opencv.org/modules/core/doc/drawing_functions.html#fillpoly%s', None),
-            'rng' : ('http://docs.opencv.org/modules/core/doc/operations_on_arrays.html?highlight=rng#rng%s', None),
-            'put_text' : ('http://docs.opencv.org/modules/core/doc/drawing_functions.html#puttext%s', None),
-            'gaussian_blur' : ('http://docs.opencv.org/modules/imgproc/doc/filtering.html?highlight=gaussianblur#gaussianblur%s', None),
-            'blur' : ('http://docs.opencv.org/modules/imgproc/doc/filtering.html?highlight=blur#blur%s', None),
-            'median_blur' : ('http://docs.opencv.org/modules/imgproc/doc/filtering.html?highlight=medianblur#medianblur%s', None),
-            'bilateral_filter' : ('http://docs.opencv.org/modules/imgproc/doc/filtering.html?highlight=bilateralfilter#bilateralfilter%s', None),
-            'erode' : ('http://docs.opencv.org/modules/imgproc/doc/filtering.html?highlight=erode#erode%s', None),
-            'dilate' : ('http://docs.opencv.org/modules/imgproc/doc/filtering.html?highlight=dilate#dilate%s', None),
-            'get_structuring_element' : ('http://docs.opencv.org/modules/imgproc/doc/filtering.html?highlight=getstructuringelement#getstructuringelement%s', None),
-            'flood_fill' : ( 'http://docs.opencv.org/modules/imgproc/doc/miscellaneous_transformations.html?highlight=floodfill#floodfill%s', None),
-            'morphology_ex' : ('http://docs.opencv.org/modules/imgproc/doc/filtering.html?highlight=morphologyex#morphologyex%s', None),
-            'pyr_down' : ('http://docs.opencv.org/modules/imgproc/doc/filtering.html?highlight=pyrdown#pyrdown%s', None),
-            'pyr_up' : ('http://docs.opencv.org/modules/imgproc/doc/filtering.html?highlight=pyrup#pyrup%s', None),
-            'resize' : ('http://docs.opencv.org/modules/imgproc/doc/geometric_transformations.html?highlight=resize#resize%s', None),
-            'threshold' : ('http://docs.opencv.org/modules/imgproc/doc/miscellaneous_transformations.html?highlight=threshold#threshold%s', None),
-            'filter2d' : ('http://docs.opencv.org/modules/imgproc/doc/filtering.html?highlight=filter2d#filter2d%s', None),
-            'copy_make_border' : ('http://docs.opencv.org/modules/imgproc/doc/filtering.html?highlight=copymakeborder#copymakeborder%s', None),
-            'sobel' : ('http://docs.opencv.org/modules/imgproc/doc/filtering.html?highlight=sobel#sobel%s', None),
-            'scharr' : ('http://docs.opencv.org/modules/imgproc/doc/filtering.html?highlight=scharr#scharr%s', None),
-            'laplacian' : ('http://docs.opencv.org/modules/imgproc/doc/filtering.html?highlight=laplacian#laplacian%s', None),
-            'canny' : ('http://docs.opencv.org/modules/imgproc/doc/feature_detection.html?highlight=canny#canny%s', None),
-            'copy_to' : ('http://docs.opencv.org/modules/core/doc/basic_structures.html?highlight=copyto#mat-copyto%s', None),
+            'cvt_color': ('http://docs.opencv.org/modules/imgproc/doc/miscellaneous_transformations.html?highlight=cvtcolor#cvtcolor%s', None),
+            'imread':    ('http://docs.opencv.org/modules/highgui/doc/reading_and_writing_images_and_video.html?highlight=imread#imread%s', None),
+            'imwrite':   ('http://docs.opencv.org/modules/highgui/doc/reading_and_writing_images_and_video.html?highlight=imwrite#imwrite%s', None),
+            'imshow':    ('http://docs.opencv.org/modules/highgui/doc/user_interface.html?highlight=imshow#imshow%s', None),
+            'named_window': ('http://docs.opencv.org/modules/highgui/doc/user_interface.html?highlight=namedwindow#namedwindow%s', None),
+            'wait_key': ('http://docs.opencv.org/modules/highgui/doc/user_interface.html?highlight=waitkey#waitkey%s', None),
+            'add_weighted': ('http://docs.opencv.org/modules/core/doc/operations_on_arrays.html?highlight=addweighted#addweighted%s', None),
+            'saturate_cast': ('http://docs.opencv.org/modules/core/doc/utility_and_system_functions_and_macros.html?highlight=saturate_cast#saturate-cast%s', None),
+            'mat_zeros': ('http://docs.opencv.org/modules/core/doc/basic_structures.html?highlight=zeros#mat-zeros%s', None),
+            'convert_to': ('http://docs.opencv.org/modules/core/doc/basic_structures.html#mat-convertto%s', None),
+            'create_trackbar': ('http://docs.opencv.org/modules/highgui/doc/user_interface.html?highlight=createtrackbar#createtrackbar%s', None),
+            'point': ('http://docs.opencv.org/modules/core/doc/basic_structures.html#point%s', None),
+            'scalar': ('http://docs.opencv.org/modules/core/doc/basic_structures.html#scalar%s', None),
+            'line': ('http://docs.opencv.org/modules/core/doc/drawing_functions.html#line%s', None),
+            'ellipse': ('http://docs.opencv.org/modules/core/doc/drawing_functions.html#ellipse%s', None),
+            'rectangle': ('http://docs.opencv.org/modules/core/doc/drawing_functions.html#rectangle%s', None),
+            'circle': ('http://docs.opencv.org/modules/core/doc/drawing_functions.html#circle%s', None),
+            'fill_poly': ('http://docs.opencv.org/modules/core/doc/drawing_functions.html#fillpoly%s', None),
+            'rng': ('http://docs.opencv.org/modules/core/doc/operations_on_arrays.html?highlight=rng#rng%s', None),
+            'put_text': ('http://docs.opencv.org/modules/core/doc/drawing_functions.html#puttext%s', None),
+            'gaussian_blur': ('http://docs.opencv.org/modules/imgproc/doc/filtering.html?highlight=gaussianblur#gaussianblur%s', None),
+            'blur': ('http://docs.opencv.org/modules/imgproc/doc/filtering.html?highlight=blur#blur%s', None),
+            'median_blur': ('http://docs.opencv.org/modules/imgproc/doc/filtering.html?highlight=medianblur#medianblur%s', None),
+            'bilateral_filter': ('http://docs.opencv.org/modules/imgproc/doc/filtering.html?highlight=bilateralfilter#bilateralfilter%s', None),
+            'erode': ('http://docs.opencv.org/modules/imgproc/doc/filtering.html?highlight=erode#erode%s', None),
+            'dilate': ('http://docs.opencv.org/modules/imgproc/doc/filtering.html?highlight=dilate#dilate%s', None),
+            'get_structuring_element': ('http://docs.opencv.org/modules/imgproc/doc/filtering.html?highlight=getstructuringelement#getstructuringelement%s', None),
+            'flood_fill': ( 'http://docs.opencv.org/modules/imgproc/doc/miscellaneous_transformations.html?highlight=floodfill#floodfill%s', None),
+            'morphology_ex': ('http://docs.opencv.org/modules/imgproc/doc/filtering.html?highlight=morphologyex#morphologyex%s', None),
+            'pyr_down': ('http://docs.opencv.org/modules/imgproc/doc/filtering.html?highlight=pyrdown#pyrdown%s', None),
+            'pyr_up': ('http://docs.opencv.org/modules/imgproc/doc/filtering.html?highlight=pyrup#pyrup%s', None),
+            'resize': ('http://docs.opencv.org/modules/imgproc/doc/geometric_transformations.html?highlight=resize#resize%s', None),
+            'threshold': ('http://docs.opencv.org/modules/imgproc/doc/miscellaneous_transformations.html?highlight=threshold#threshold%s', None),
+            'filter2d': ('http://docs.opencv.org/modules/imgproc/doc/filtering.html?highlight=filter2d#filter2d%s', None),
+            'copy_make_border': ('http://docs.opencv.org/modules/imgproc/doc/filtering.html?highlight=copymakeborder#copymakeborder%s', None),
+            'sobel': ('http://docs.opencv.org/modules/imgproc/doc/filtering.html?highlight=sobel#sobel%s', None),
+            'scharr': ('http://docs.opencv.org/modules/imgproc/doc/filtering.html?highlight=scharr#scharr%s', None),
+            'laplacian': ('http://docs.opencv.org/modules/imgproc/doc/filtering.html?highlight=laplacian#laplacian%s', None),
+            'canny': ('http://docs.opencv.org/modules/imgproc/doc/feature_detection.html?highlight=canny#canny%s', None),
+            'copy_to': ('http://docs.opencv.org/modules/core/doc/basic_structures.html?highlight=copyto#mat-copyto%s', None),
            'hough_lines' : ('http://docs.opencv.org/modules/imgproc/doc/feature_detection.html?highlight=houghlines#houghlines%s', None),
            'hough_lines_p' : ('http://docs.opencv.org/modules/imgproc/doc/feature_detection.html?highlight=houghlinesp#houghlinesp%s', None),
            'hough_circles' : ('http://docs.opencv.org/modules/imgproc/doc/feature_detection.html?highlight=houghcircles#houghcircles%s', None),
@@ -492,7 +492,7 @@ class=Typewch><span lang=EN-US>- weighttrimming &lt;weight_trimming&gt;</span></
 <p class=MsoNormal style='margin-left:17.1pt;text-indent:-17.1pt'><span
 class=Typewch><span lang=EN-US>  </span></span><span class=Typewch><span
 lang=EN-US style='font-family:"Times New Roman";font-weight:normal'>Specifies
-whether and how much weight trimming should be used. A decent choice is 0.90.</span></span></p>
+wheter and how much weight trimming should be used. A decent choice is 0.90.</span></span></p>

 <p class=MsoNormal style='margin-left:17.1pt;text-indent:-17.1pt'><span
 class=Typewch><span lang=EN-US>- eqw</span></span></p>
@@ -6,12 +6,12 @@ Adding (blending) two images using OpenCV
 Goal
 =====

-In this tutorial you will learn:
+In this tutorial you will learn how to:

 .. container:: enumeratevisibleitemswithsquare

-   * what is *linear blending* and why it is useful;
-   * how to add two images using :add_weighted:`addWeighted <>`
+   * What is *linear blending* and why it is useful.
+   * Add two images using :add_weighted:`addWeighted <>`

 Theory
 =======
@@ -18,7 +18,7 @@ We'll seek answers for the following questions:
 Our test case
 =============

-Let us consider a simple color reduction method. By using the unsigned char C and C++ type for matrix item storing, a channel of pixel may have up to 256 different values. For a three channel image this can allow the formation of way too many colors (16 million to be exact). Working with so many color shades may give a heavy blow to our algorithm performance. However, sometimes it is enough to work with a lot less of them to get the same final result.
+Let us consider a simple color reduction method. Using the unsigned char C and C++ type for matrix item storing a channel of pixel may have up to 256 different values. For a three channel image this can allow the formation of way too many colors (16 million to be exact). Working with so many color shades may give a heavy blow to our algorithm performance. However, sometimes it is enough to work with a lot less of them to get the same final result.

 In this cases it's common that we make a *color space reduction*. This means that we divide the color space current value with a new input value to end up with fewer colors. For instance every value between zero and nine takes the new value zero, every value between ten and nineteen the value ten and so on.

@@ -32,14 +32,14 @@ Here's a function that will do this:

 .. code-block:: cpp

-   void Sharpen(const Mat& myImage, Mat& Result)
+   void Sharpen(const Mat& myImage,Mat& Result)
   {
       CV_Assert(myImage.depth() == CV_8U);  // accept only uchar images

-       Result.create(myImage.size(), myImage.type());
+       Result.create(myImage.size(),myImage.type());
       const int nChannels = myImage.channels();

-       for(int j = 1; j < myImage.rows - 1; ++j)
+       for(int j = 1 ; j < myImage.rows-1; ++j)
       {
           const uchar* previous = myImage.ptr<uchar>(j - 1);
           const uchar* current  = myImage.ptr<uchar>(j    );
@@ -47,17 +47,17 @@ Here's a function that will do this:

           uchar* output = Result.ptr<uchar>(j);

-           for(int i = nChannels; i < nChannels * (myImage.cols - 1); ++i)
+           for(int i= nChannels;i < nChannels*(myImage.cols-1); ++i)
           {
-               *output++ = saturate_cast<uchar>(5 * current[i]
-                            -current[i - nChannels] - current[i + nChannels] - previous[i] - next[i]);
+               *output++ = saturate_cast<uchar>(5*current[i]
+                            -current[i-nChannels] - current[i+nChannels] - previous[i] - next[i]);
           }
       }

       Result.row(0).setTo(Scalar(0));
-       Result.row(Result.rows - 1).setTo(Scalar(0));
+       Result.row(Result.rows-1).setTo(Scalar(0));
       Result.col(0).setTo(Scalar(0));
-       Result.col(Result.cols - 1).setTo(Scalar(0));
+       Result.col(Result.cols-1).setTo(Scalar(0));
   }

 At first we make sure that the input images data is in unsigned char format. For this we use the :utilitysystemfunctions:`CV_Assert <cv-assert>` function that throws an error when the expression inside it is false.
@@ -70,14 +70,14 @@ We create an output image with the same size and the same type as our input. As

 .. code-block:: cpp

-   Result.create(myImage.size(), myImage.type());
+   Result.create(myImage.size(),myImage.type());
   const int nChannels = myImage.channels();

 We'll use the plain C [] operator to access pixels. Because we need to access multiple rows at the same time we'll acquire the pointers for each of them (a previous, a current and a next line). We need another pointer to where we're going to save the calculation. Then simply access the right items with the [] operator. For moving the output pointer ahead we simply increase this (with one byte) after each operation:

 .. code-block:: cpp

-   for(int j = 1; j < myImage.rows - 1; ++j)
+   for(int j = 1 ; j < myImage.rows-1; ++j)
   {
       const uchar* previous = myImage.ptr<uchar>(j - 1);
       const uchar* current  = myImage.ptr<uchar>(j    );
@@ -85,21 +85,21 @@ We'll use the plain C [] operator to access pixels. Because we need to access mu

       uchar* output = Result.ptr<uchar>(j);

-       for(int i = nChannels; i < nChannels * (myImage.cols - 1); ++i)
+       for(int i= nChannels;i < nChannels*(myImage.cols-1); ++i)
       {
-           *output++ = saturate_cast<uchar>(5 * current[i]
-                        -current[i - nChannels] - current[i + nChannels] - previous[i] - next[i]);
+           *output++ = saturate_cast<uchar>(5*current[i]
+                        -current[i-nChannels] - current[i+nChannels] - previous[i] - next[i]);
       }
   }

-On the borders of the image the upper notation results inexistent pixel locations (like minus one - minus one). In these points our formula is undefined. A simple solution is to not apply the kernel in these points and, for example, set the pixels on the borders to zeros:
+On the borders of the image the upper notation results inexistent pixel locations (like minus one - minus one). In these points our formula is undefined. A simple solution is to not apply the mask in these points and, for example, set the pixels on the borders to zeros:

 .. code-block:: cpp

-   Result.row(0).setTo(Scalar(0));               // The top row
-   Result.row(Result.rows - 1).setTo(Scalar(0)); // The bottom row
-   Result.col(0).setTo(Scalar(0));               // The left column
-   Result.col(Result.cols - 1).setTo(Scalar(0)); // The right column
+   Result.row(0).setTo(Scalar(0));             // The top row
+   Result.row(Result.rows-1).setTo(Scalar(0)); // The bottom row
+   Result.col(0).setTo(Scalar(0));             // The left column
+   Result.col(Result.cols-1).setTo(Scalar(0)); // The right column

 The filter2D function
 =====================
@@ -116,7 +116,7 @@ Then call the :filtering:`filter2D <filter2d>` function specifying the input, th

 .. code-block:: cpp

-   filter2D(I, K, I.depth(), kern);
+   filter2D(I, K, I.depth(), kern );

 The function even has a fifth optional argument to specify the center of the kernel, and a sixth one for determining what to do in the regions where the operation is undefined (borders). Using this function has the advantage that it's shorter, less verbose and because there are some optimization techniques implemented it is usually faster than the *hand-coded method*. For example in my test while the second one took only 13 milliseconds the first took around 31 milliseconds. Quite some difference.

@@ -45,7 +45,7 @@ All the above objects, in the end, point to the same single data matrix. Their h
   :linenos:

   Mat D (A, Rect(10, 10, 100, 100) ); // using a rectangle
-   Mat E = A(Range::all(), Range(1,3)); // using row and column boundaries
+   Mat E = A(Range:all(), Range(1,3)); // using row and column boundaries

 Now you may ask if the matrix itself may belong to multiple *Mat* objects who takes responsibility for cleaning it up when it's no longer needed. The short answer is: the last object that used it. This is handled by using a reference counting mechanism. Whenever somebody copies a header of a *Mat* object, a counter is increased for the matrix. Whenever a header is cleaned this counter is decreased. When the counter reaches zero the matrix too is freed. Sometimes you will want to copy the matrix itself too, so OpenCV provides the :basicstructures:`clone() <mat-clone>` and :basicstructures:`copyTo() <mat-copyto>` functions.

@@ -86,7 +86,7 @@ Each of the building components has their own valid domains. This leads to the d
 Creating a *Mat* object explicitly
 ==================================

-In the :ref:`Load_Save_Image` tutorial you have already learned how to write a matrix to an image file by using the :readwriteimagevideo:`imwrite() <imwrite>` function. However, for debugging purposes it's much more convenient to see the actual values. You can do this using the << operator of *Mat*. Be aware that this only works for two dimensional matrices.
+In the :ref:`Load_Save_Image` tutorial you have already learned how to write a matrix to an image file by using the :readWriteImageVideo:` imwrite() <imwrite>` function. However, for debugging purposes it's much more convenient to see the actual values. You can do this using the << operator of *Mat*. Be aware that this only works for two dimensional matrices.

 Although *Mat* works really well as an image container, it is also a general matrix class. Therefore, it is possible to create and manipulate multidimensional matrices. You can create a Mat object in multiple ways:

@@ -84,10 +84,88 @@ Code

   * **Code at glance:**

-.. literalinclude:: ../../../../../samples/cpp/tutorial_code/Histograms_Matching/compareHist_Demo.cpp
-   :language: cpp
-   :tab-width: 4
+.. code-block:: cpp

+   #include "opencv2/highgui/highgui.hpp"
+   #include "opencv2/imgproc/imgproc.hpp"
+   #include <iostream>
+   #include <stdio.h>
+
+   using namespace std;
+   using namespace cv;
+
+   /** @function main */
+   int main( int argc, char** argv )
+   {
+     Mat src_base, hsv_base;
+     Mat src_test1, hsv_test1;
+     Mat src_test2, hsv_test2;
+     Mat hsv_half_down;
+
+     /// Load three images with different environment settings
+     if( argc < 4 )
+       { printf("** Error. Usage: ./compareHist_Demo <image_settings0> <image_setting1> <image_settings2>\n");
+         return -1;
+       }
+
+     src_base = imread( argv[1], 1 );
+     src_test1 = imread( argv[2], 1 );
+     src_test2 = imread( argv[3], 1 );
+
+     /// Convert to HSV
+     cvtColor( src_base, hsv_base, CV_BGR2HSV );
+     cvtColor( src_test1, hsv_test1, CV_BGR2HSV );
+     cvtColor( src_test2, hsv_test2, CV_BGR2HSV );
+
+     hsv_half_down = hsv_base( Range( hsv_base.rows/2, hsv_base.rows - 1 ), Range( 0, hsv_base.cols - 1 ) );
+
+     /// Using 30 bins for hue and 32 for saturation
+     int h_bins = 50; int s_bins = 60;
+     int histSize[] = { h_bins, s_bins };
+
+     // hue varies from 0 to 256, saturation from 0 to 180
+     float h_ranges[] = { 0, 256 };
+     float s_ranges[] = { 0, 180 };
+
+     const float* ranges[] = { h_ranges, s_ranges };
+
+     // Use the o-th and 1-st channels
+     int channels[] = { 0, 1 };
+
+     /// Histograms
+     MatND hist_base;
+     MatND hist_half_down;
+     MatND hist_test1;
+     MatND hist_test2;
+
+     /// Calculate the histograms for the HSV images
+     calcHist( &hsv_base, 1, channels, Mat(), hist_base, 2, histSize, ranges, true, false );
+     normalize( hist_base, hist_base, 0, 1, NORM_MINMAX, -1, Mat() );
+
+     calcHist( &hsv_half_down, 1, channels, Mat(), hist_half_down, 2, histSize, ranges, true, false );
+     normalize( hist_half_down, hist_half_down, 0, 1, NORM_MINMAX, -1, Mat() );
+
+     calcHist( &hsv_test1, 1, channels, Mat(), hist_test1, 2, histSize, ranges, true, false );
+     normalize( hist_test1, hist_test1, 0, 1, NORM_MINMAX, -1, Mat() );
+
+     calcHist( &hsv_test2, 1, channels, Mat(), hist_test2, 2, histSize, ranges, true, false );
+     normalize( hist_test2, hist_test2, 0, 1, NORM_MINMAX, -1, Mat() );
+
+     /// Apply the histogram comparison methods
+     for( int i = 0; i < 4; i++ )
+        { int compare_method = i;
+          double base_base = compareHist( hist_base, hist_base, compare_method );
+          double base_half = compareHist( hist_base, hist_half_down, compare_method );
+          double base_test1 = compareHist( hist_base, hist_test1, compare_method );
+          double base_test2 = compareHist( hist_base, hist_test2, compare_method );
+
+          printf( " Method [%d] Perfect, Base-Half, Base-Test(1), Base-Test(2) : %f, %f, %f, %f \n", i, base_base, base_half , base_test1, base_test2 );
+        }
+
+     printf( "Done \n" );
+
+     return 0;
+    }


 Explanation
@@ -133,11 +211,11 @@ Explanation

   .. code-block:: cpp

-     int h_bins = 50; int s_bins = 60;
+     int h_bins = 50; int s_bins = 32;
     int histSize[] = { h_bins, s_bins };

-     float h_ranges[] = { 0, 180 };
-     float s_ranges[] = { 0, 256 };
+     float h_ranges[] = { 0, 256 };
+     float s_ranges[] = { 0, 180 };

     const float* ranges[] = { h_ranges, s_ranges };

@@ -85,7 +85,7 @@ d. **method=CV\_TM\_CCORR\_NORMED**

   .. math::

-      R(x,y)= \frac{\sum_{x',y'} (T(x',y') \cdot I(x+x',y+y'))}{\sqrt{\sum_{x',y'}T(x',y')^2 \cdot \sum_{x',y'} I(x+x',y+y')^2}}
+      R(x,y)= \frac{\sum_{x',y'} (T(x',y') \cdot I'(x+x',y+y'))}{\sqrt{\sum_{x',y'}T(x',y')^2 \cdot \sum_{x',y'} I(x+x',y+y')^2}}


 e. **method=CV\_TM\_CCOEFF**
@@ -48,10 +48,10 @@ The structure of package contents looks as follows:

 ::

-    OpenCV-2.4.9-android-sdk
+    OpenCV-2.4.8.2-android-sdk
    |_ apk
-    |   |_ OpenCV_2.4.9_binary_pack_armv7a.apk
-    |   |_ OpenCV_2.4.9_Manager_2.18_XXX.apk
+    |   |_ OpenCV_2.4.8.2_binary_pack_armv7a.apk
+    |   |_ OpenCV_2.4.8.2_Manager_2.17_XXX.apk
    |
    |_ doc
    |_ samples
@@ -157,10 +157,10 @@ Get the OpenCV4Android SDK

   .. code-block:: bash

-      unzip ~/Downloads/OpenCV-2.4.9-android-sdk.zip
+      unzip ~/Downloads/OpenCV-2.4.8.2-android-sdk.zip

-.. |opencv_android_bin_pack| replace:: :file:`OpenCV-2.4.9-android-sdk.zip`
-.. _opencv_android_bin_pack_url: http://sourceforge.net/projects/opencvlibrary/files/opencv-android/2.4.9/OpenCV-2.4.9-android-sdk.zip/download
+.. |opencv_android_bin_pack| replace:: :file:`OpenCV-2.4.8.2-android-sdk.zip`
+.. _opencv_android_bin_pack_url: http://sourceforge.net/projects/opencvlibrary/files/opencv-android/2.4.8.2/OpenCV-2.4.8.2-android-sdk.zip/download
 .. |opencv_android_bin_pack_url| replace:: |opencv_android_bin_pack|
 .. |seven_zip| replace:: 7-Zip
 .. _seven_zip: http://www.7-zip.org/
@@ -295,7 +295,7 @@ Well, running samples from Eclipse is very simple:
  .. code-block:: sh
    :linenos:

-    <Android SDK path>/platform-tools/adb install <OpenCV4Android SDK path>/apk/OpenCV_2.4.9_Manager_2.18_armv7a-neon.apk
+    <Android SDK path>/platform-tools/adb install <OpenCV4Android SDK path>/apk/OpenCV_2.4.8.2_Manager_2.17_armv7a-neon.apk

  .. note:: ``armeabi``, ``armv7a-neon``, ``arm7a-neon-android8``, ``mips`` and ``x86`` stand for
            platform targets:
@@ -55,14 +55,14 @@ Manager to access OpenCV libraries externally installed in the target system.
   :guilabel:`File -> Import -> Existing project in your workspace`.

   Press :guilabel:`Browse`  button and locate OpenCV4Android SDK
-   (:file:`OpenCV-2.4.9-android-sdk/sdk`).
+   (:file:`OpenCV-2.4.8.2-android-sdk/sdk`).

   .. image:: images/eclipse_opencv_dependency0.png
        :alt: Add dependency from OpenCV library
        :align: center

 #. In application project add a reference to the OpenCV Java SDK in
-   :guilabel:`Project -> Properties -> Android -> Library -> Add` select ``OpenCV Library - 2.4.9``.
+   :guilabel:`Project -> Properties -> Android -> Library -> Add` select ``OpenCV Library - 2.4.8.2``.

   .. image:: images/eclipse_opencv_dependency1.png
        :alt: Add dependency from OpenCV library
@@ -128,27 +128,27 @@ described above.
 #. Add the OpenCV library project to your workspace the same way as for the async initialization
   above. Use menu :guilabel:`File -> Import -> Existing project in your workspace`,
   press :guilabel:`Browse` button and select OpenCV SDK path
-   (:file:`OpenCV-2.4.9-android-sdk/sdk`).
+   (:file:`OpenCV-2.4.8.2-android-sdk/sdk`).

   .. image:: images/eclipse_opencv_dependency0.png
        :alt: Add dependency from OpenCV library
        :align: center

 #. In the application project add a reference to the OpenCV4Android SDK in
-   :guilabel:`Project -> Properties -> Android -> Library -> Add` select ``OpenCV Library - 2.4.9``;
+   :guilabel:`Project -> Properties -> Android -> Library -> Add` select ``OpenCV Library - 2.4.8.2``;

   .. image:: images/eclipse_opencv_dependency1.png
       :alt: Add dependency from OpenCV library
       :align: center

 #. If your application project **doesn't have a JNI part**, just copy the corresponding OpenCV
-   native libs from :file:`<OpenCV-2.4.9-android-sdk>/sdk/native/libs/<target_arch>` to your
+   native libs from :file:`<OpenCV-2.4.8.2-android-sdk>/sdk/native/libs/<target_arch>` to your
   project directory to folder :file:`libs/<target_arch>`.

   In case of the application project **with a JNI part**, instead of manual libraries copying you
   need to modify your ``Android.mk`` file:
   add the following two code lines after the ``"include $(CLEAR_VARS)"`` and before
-   ``"include path_to_OpenCV-2.4.9-android-sdk/sdk/native/jni/OpenCV.mk"``
+   ``"include path_to_OpenCV-2.4.8.2-android-sdk/sdk/native/jni/OpenCV.mk"``

   .. code-block:: make
      :linenos:
@@ -221,7 +221,7 @@ taken:

   .. code-block:: make

-      include C:\Work\OpenCV4Android\OpenCV-2.4.9-android-sdk\sdk\native\jni\OpenCV.mk
+      include C:\Work\OpenCV4Android\OpenCV-2.4.8.2-android-sdk\sdk\native\jni\OpenCV.mk

   Should be inserted into the :file:`jni/Android.mk` file **after** this line:

@@ -382,7 +382,7 @@ result.
           OpenCVLoader.initAsync(OpenCVLoader.OPENCV_VERSION_2_4_6, this, mLoaderCallback);
       }

-#. Defines that your activity implements ``CvCameraViewListener2`` interface and fix activity related
+#. Defines that your activity implements ``CvViewFrameListener2`` interface and fix activity related
   errors by defining missed methods. For this activity define ``onCreate``, ``onDestroy`` and
   ``onPause`` and implement them according code snippet bellow. Fix errors by adding requited
   imports.
@@ -432,7 +432,7 @@ result.
 Lets discuss some most important steps. Every Android application with UI must implement Activity
 and View. By the first steps we create blank activity and default view layout. The simplest
 OpenCV-centric application must implement OpenCV initialization, create its own view to show
-preview from camera and implements ``CvCameraViewListener2`` interface to get frames from camera and
+preview from camera and implements ``CvViewFrameListener2`` interface to get frames from camera and
 process it.

 First of all we create our application view using xml layout. Our layout consists of the only
@@ -25,34 +25,29 @@ Let's use a simple program such as DisplayImage.cpp shown below.

 .. code-block:: cpp

-  #include <stdio.h>
-  #include <opencv2/opencv.hpp>
+   #include <stdio.h>
+   #include <opencv2/opencv.hpp>

-  using namespace cv;
+   using namespace cv;

-  int main(int argc, char** argv )
-  {
-      if ( argc != 2 )
-      {
-          printf("usage: DisplayImage.out <Image_Path>\n");
-          return -1;
-      }
+   int main( int argc, char** argv )
+   {
+     Mat image;
+     image = imread( argv[1], 1 );

-      Mat image;
-      image = imread( argv[1], 1 );
+     if( argc != 2 || !image.data )
+       {
+         printf( "No image data \n" );
+         return -1;
+       }

-      if ( !image.data )
-      {
-          printf("No image data \n");
-          return -1;
-      }
-      namedWindow("Display Image", CV_WINDOW_AUTOSIZE );
-      imshow("Display Image", image);
+     namedWindow( "Display Image", CV_WINDOW_AUTOSIZE );
+     imshow( "Display Image", image );

-      waitKey(0);
+     waitKey(0);

-      return 0;
-  }
+     return 0;
+   }

 Create a CMake file
 ---------------------
@@ -5,7 +5,7 @@ Load, Modify, and Save an Image

 .. note::

-   We assume that by now you know how to load an image using :readwriteimagevideo:`imread <imread>` and to display it in a window (using :user_interface:`imshow <imshow>`). Read the :ref:`Display_Image` tutorial otherwise.
+   We assume that by now you know how to load an image using :imread:`imread <>` and to display it in a window (using :imshow:`imshow <>`). Read the :ref:`Display_Image` tutorial otherwise.

 Goals
 ======
@@ -14,9 +14,9 @@ In this tutorial you will learn how to:

 .. container:: enumeratevisibleitemswithsquare

-   * Load an image using :readwriteimagevideo:`imread <imread>`
-   * Transform an image from BGR to Grayscale format by using :miscellaneous_transformations:`cvtColor <cvtcolor>`
-   * Save your transformed image in a file on disk (using :readwriteimagevideo:`imwrite <imwrite>`)
+   * Load an image using :imread:`imread <>`
+   * Transform an image from BGR to Grayscale format by using :cvt_color:`cvtColor <>`
+   * Save your transformed image in a file on disk (using :imwrite:`imwrite <>`)

 Code
 ======
@@ -63,7 +63,10 @@ Here it is:
 Explanation
 ============

-#. We begin by loading an image using :readwriteimagevideo:`imread <imread>`, located in the path given by *imageName*. For this example, assume you are loading a RGB image.
+#. We begin by:
+
+   * Creating a Mat object to store the image information
+   * Load an image using :imread:`imread <>`, located in the path given by *imageName*. Fort this example, assume you are loading a RGB image.

 #. Now we are going to convert our image from BGR to Grayscale format. OpenCV has a really nice function to do this kind of transformations:

@@ -71,15 +74,15 @@ Explanation

      cvtColor( image, gray_image, CV_BGR2GRAY );

-   As you can see, :miscellaneous_transformations:`cvtColor <cvtcolor>` takes as arguments:
+   As you can see, :cvt_color:`cvtColor <>` takes as arguments:

   .. container:: enumeratevisibleitemswithsquare

      * a source image (*image*)
      * a destination image (*gray_image*), in which we will save the converted image.
-      * an additional parameter that indicates what kind of transformation will be performed. In this case we use **CV_BGR2GRAY** (because of :readwriteimagevideo:`imread <imread>` has BGR default channel order in case of color images).
+      * an additional parameter that indicates what kind of transformation will be performed. In this case we use **CV_BGR2GRAY** (because of :imread:`imread <>` has BGR default channel order in case of color images).

-#. So now we have our new *gray_image* and want to save it on disk (otherwise it will get lost after the program ends). To save it, we will use a function analagous to :readwriteimagevideo:`imread <imread>`: :readwriteimagevideo:`imwrite <imwrite>`
+#. So now we have our new *gray_image* and want to save it on disk (otherwise it will get lost after the program ends). To save it, we will use a function analagous to :imread:`imread <>`: :imwrite:`imwrite <>`

   .. code-block:: cpp

@@ -97,7 +100,7 @@ Explanation
      imshow( imageName, image );
      imshow( "Gray image", gray_image );

-#. Add the *waitKey(0)* function call for the program to wait forever for an user key press.
+#. Add add the *waitKey(0)* function call for the program to wait forever for an user key press.


 Result
@@ -81,7 +81,7 @@ Building the OpenCV library from scratch requires a couple of tools installed be

   + An IDE of choice (preferably), or just a C\C++ compiler that will actually make the binary files. Here we will use the `Microsoft Visual Studio <https://www.microsoft.com/visualstudio/en-us>`_. However, you can use any other IDE that has a valid C\C++ compiler.

-   + |CMake|_, which is a neat tool to make the project files (for your chosen IDE) from the OpenCV source files. It will also allow an easy configuration of the OpenCV build files, in order to make binary files that fits exactly to your needs.
+   + |CMake|_, which is a neat tool to make the project files (for your choosen IDE) from the OpenCV source files. It will also allow an easy configuration of the OpenCV build files, in order to make binary files that fits exactly to your needs.

   + Git to acquire the OpenCV source files. A good tool for this is |TortoiseGit|_. Alternatively, you can just download an archived version of the source files from our `page on Sourceforge <http://sourceforge.net/projects/opencvlibrary/files/opencv-win/>`_

@@ -102,7 +102,7 @@ As always, we would be happy to hear your comments and receive your contribution
   .. cssclass:: toctableopencv

   =========== =======================================================
-   |Video|     Look here in order to find use on your video stream algorithms like: motion extraction, feature tracking and foreground extractions.
+   |Video|     Look here in order to find use on your video stream algoritms like: motion extraction, feature tracking and foreground extractions.

   =========== =======================================================

@@ -186,21 +186,6 @@ As always, we would be happy to hear your comments and receive your contribution
                    :width:  80pt
                    :alt: gpu icon

-*  :ref:`Table-Of-Content-Viz`
-
-   .. tabularcolumns:: m{100pt} m{300pt}
-   .. cssclass:: toctableopencv
-
-   =========== =======================================================
-      |Viz|     These tutorials show how to use Viz module effectively.
-
-   =========== =======================================================
-
-     .. |Viz| image:: images/viz.jpg
-                   :height: 80pt
-                   :width:  80pt
-                   :alt: viz icon
-
 *  :ref:`Table-Of-Content-General`

      .. tabularcolumns:: m{100pt} m{300pt}
@@ -236,5 +221,4 @@ As always, we would be happy to hear your comments and receive your contribution
   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
-   viz/table_of_content_viz/table_of_content_viz
   general/table_of_content_general/table_of_content_general
@@ -3,7 +3,7 @@
 *video* module. Video analysis
 -----------------------------------------------------------

-Look here in order to find use on your video stream algorithms like: motion extraction, feature tracking and foreground extractions.
+Look here in order to find use on your video stream algoritms like: motion extraction, feature tracking and foreground extractions.

 .. include:: ../../definitions/noContent.rst

@@ -1,159 +0,0 @@
-.. _creating_widgets:
-
-Creating Widgets
-****************
-
-Goal
-====
-
-In this tutorial you will learn how to
-
-.. container:: enumeratevisibleitemswithsquare
-
-  * Create your own widgets using WidgetAccessor and VTK.
-  * Show your widget in the visualization window.
-
-Code
-====
-
-You can download the code from :download:`here <../../../../samples/cpp/tutorial_code/viz/creating_widgets.cpp>`.
-
-.. code-block:: cpp
-
-    #include <opencv2/viz/vizcore.hpp>
-    #include <opencv2/viz/widget_accessor.hpp>
-    #include <iostream>
-
-    #include <vtkPoints.h>
-    #include <vtkTriangle.h>
-    #include <vtkCellArray.h>
-    #include <vtkPolyData.h>
-    #include <vtkPolyDataMapper.h>
-    #include <vtkIdList.h>
-    #include <vtkActor.h>
-    #include <vtkProp.h>
-
-    using namespace cv;
-    using namespace std;
-
-    /**
-     * @class WTriangle
-     * @brief Defining our own 3D Triangle widget
-     */
-    class WTriangle : public viz::Widget3D
-    {
-        public:
-            WTriangle(const Point3f &pt1, const Point3f &pt2, const Point3f &pt3, const viz::Color & color = viz::Color::white());
-    };
-
-    /**
-     * @function WTriangle::WTriangle
-     */
-    WTriangle::WTriangle(const Point3f &pt1, const Point3f &pt2, const Point3f &pt3, const viz::Color & color)
-    {
-        // Create a triangle
-        vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
-        points->InsertNextPoint(pt1.x, pt1.y, pt1.z);
-        points->InsertNextPoint(pt2.x, pt2.y, pt2.z);
-        points->InsertNextPoint(pt3.x, pt3.y, pt3.z);
-
-        vtkSmartPointer<vtkTriangle> triangle = vtkSmartPointer<vtkTriangle>::New();
-        triangle->GetPointIds()->SetId(0,0);
-        triangle->GetPointIds()->SetId(1,1);
-        triangle->GetPointIds()->SetId(2,2);
-
-        vtkSmartPointer<vtkCellArray> cells = vtkSmartPointer<vtkCellArray>::New();
-        cells->InsertNextCell(triangle);
-
-        // Create a polydata object
-        vtkSmartPointer<vtkPolyData> polyData = vtkSmartPointer<vtkPolyData>::New();
-
-        // Add the geometry and topology to the polydata
-        polyData->SetPoints(points);
-        polyData->SetPolys(cells);
-
-        // Create mapper and actor
-        vtkSmartPointer<vtkPolyDataMapper> mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
-    #if VTK_MAJOR_VERSION <= 5
-        mapper->SetInput(polyData);
-    #else
-        mapper->SetInputData(polyData);
-    #endif
-
-        vtkSmartPointer<vtkActor> actor = vtkSmartPointer<vtkActor>::New();
-        actor->SetMapper(mapper);
-
-        // Store this actor in the widget in order that visualizer can access it
-        viz::WidgetAccessor::setProp(*this, actor);
-
-        // Set the color of the widget. This has to be called after WidgetAccessor.
-        setColor(color);
-    }
-
-    /**
-     * @function main
-     */
-    int main()
-    {
-        /// Create a window
-        viz::Viz3d myWindow("Creating Widgets");
-
-        /// Create a triangle widget
-        WTriangle tw(Point3f(0.0,0.0,0.0), Point3f(1.0,1.0,1.0), Point3f(0.0,1.0,0.0), viz::Color::red());
-
-        /// Show widget in the visualizer window
-        myWindow.showWidget("TRIANGLE", tw);
-
-        /// Start event loop
-        myWindow.spin();
-
-        return 0;
-    }
-
-Explanation
-===========
-
-Here is the general structure of the program:
-
-* Extend Widget3D class to create a new 3D widget.
-
-.. code-block:: cpp
-
-    class WTriangle : public viz::Widget3D
-    {
-        public:
-            WTriangle(const Point3f &pt1, const Point3f &pt2, const Point3f &pt3, const viz::Color & color = viz::Color::white());
-    };
-
-* Assign a VTK actor to the widget.
-
-.. code-block:: cpp
-
-    // Store this actor in the widget in order that visualizer can access it
-    viz::WidgetAccessor::setProp(*this, actor);
-
-* Set color of the widget.
-
-.. code-block:: cpp
-
-    // Set the color of the widget. This has to be called after WidgetAccessor.
-    setColor(color);
-
-* Construct a triangle widget and display it in the window.
-
-.. code-block:: cpp
-
-    /// Create a triangle widget
-    WTriangle tw(Point3f(0.0,0.0,0.0), Point3f(1.0,1.0,1.0), Point3f(0.0,1.0,0.0), viz::Color::red());
-
-    /// Show widget in the visualizer window
-    myWindow.showWidget("TRIANGLE", tw);
-
-Results
-=======
-
-Here is the result of the program.
-
-.. image:: images/red_triangle.png
-    :alt: Creating Widgets
-    :align: center
@@ -1,118 +0,0 @@
-.. _launching_viz:
-
-Launching Viz
-*************
-
-Goal
-====
-
-In this tutorial you will learn how to
-
-.. container:: enumeratevisibleitemswithsquare
-
-  * Open a visualization window.
-  * Access a window by its name.
-  * Start event loop.
-  * Start event loop for a given amount of time.
-
-Code
-====
-
-You can download the code from :download:`here <../../../../samples/cpp/tutorial_code/viz/launching_viz.cpp>`.
-
-.. code-block:: cpp
-
-    #include <opencv2/viz/vizcore.hpp>
-    #include <iostream>
-
-    using namespace cv;
-    using namespace std;
-
-    /**
-    * @function main
-    */
-    int main()
-    {
-        /// Create a window
-        viz::Viz3d myWindow("Viz Demo");
-
-        /// Start event loop
-        myWindow.spin();
-
-        /// Event loop is over when pressed q, Q, e, E
-        cout << "First event loop is over" << endl;
-
-        /// Access window via its name
-        viz::Viz3d sameWindow = viz::getWindowByName("Viz Demo");
-
-        /// Start event loop
-        sameWindow.spin();
-
-        /// Event loop is over when pressed q, Q, e, E
-        cout << "Second event loop is over" << endl;
-
-        /// Event loop is over when pressed q, Q, e, E
-        /// Start event loop once for 1 millisecond
-        sameWindow.spinOnce(1, true);
-        while(!sameWindow.wasStopped())
-        {
-            /// Interact with window
-
-            /// Event loop for 1 millisecond
-            sameWindow.spinOnce(1, true);
-        }
-
-        /// Once more event loop is stopped
-        cout << "Last event loop is over" << endl;
-        return 0;
-    }
-
-Explanation
-===========
-
-Here is the general structure of the program:
-
-* Create a window.
-
-.. code-block:: cpp
-
-    /// Create a window
-    viz::Viz3d myWindow("Viz Demo");
-
-* Start event loop. This event loop will run until user terminates it by pressing **e**, **E**, **q**, **Q**.
-
-.. code-block:: cpp
-
-    /// Start event loop
-    myWindow.spin();
-
-* Access same window via its name. Since windows are implicitly shared, **sameWindow** is exactly the same with **myWindow**. If the name does not exist, a new window is created.
-
-.. code-block:: cpp
-
-    /// Access window via its name
-    viz::Viz3d sameWindow = viz::get("Viz Demo");
-
-* Start a controlled event loop. Once it starts, **wasStopped** is set to false. Inside the while loop, in each iteration, **spinOnce** is called to prevent event loop from completely stopping. Inside the while loop, user can execute other statements including those which interact with the window.
-
-.. code-block:: cpp
-
-    /// Event loop is over when pressed q, Q, e, E
-    /// Start event loop once for 1 millisecond
-    sameWindow.spinOnce(1, true);
-    while(!sameWindow.wasStopped())
-    {
-        /// Interact with window
-
-        /// Event loop for 1 millisecond
-        sameWindow.spinOnce(1, true);
-    }
-
-Results
-=======
-
-Here is the result of the program.
-
-.. image:: images/window_demo.png
-    :alt: Launching Viz
-    :align: center
@@ -1,94 +0,0 @@
-.. _Table-Of-Content-Viz:
-
-**OpenCV Viz**
-----------------------------------------------------------
-
-.. include:: ../../definitions/tocDefinitions.rst
-
-+
-  .. tabularcolumns:: m{100pt} m{300pt}
-  .. cssclass:: toctableopencv
-
-  ================== ===============================================================================
-   |VizLaunchingViz|   **Title:** :ref:`launching_viz`
-
-                       *Compatibility:* > OpenCV 3.0.0
-
-                       *Author:* Ozan Tonkal
-
-                       You will learn how to launch a viz window.
-
-  ================== ===============================================================================
-
-  .. |VizLaunchingViz| image:: ../launching_viz/images/window_demo.png
-                         :height: 120pt
-                         :width:  90pt
-
-+
-  .. tabularcolumns:: m{100pt} m{300pt}
-  .. cssclass:: toctableopencv
-
-  ================ ============================================================================
-    |WidgetPose|    **Title:** :ref:`widget_pose`
-
-                    *Compatibility:* > OpenCV 3.0.0
-
-                    *Author:* Ozan Tonkal
-
-                    You will learn how to change pose of a widget.
-
-  ================ ============================================================================
-
-  .. |WidgetPose|  image:: ../widget_pose/images/widgetpose.png
-                        :height: 90pt
-                        :width:  90pt
-
-+
-  .. tabularcolumns:: m{100pt} m{300pt}
-  .. cssclass:: toctableopencv
-
-  ==================  ============================================================================
-   |Transformations|   **Title:** :ref:`transformations`
-
-                       *Compatibility:* > OpenCV 3.0.0
-
-                       *Author:* Ozan Tonkal
-
-                       You will learn how to transform between global and camera frames.
-
-  ==================  ============================================================================
-
-  .. |Transformations| image:: ../transformations/images/global_view_point.png
-                           :height: 120pt
-                           :width:  90pt
-
-+
-  .. tabularcolumns:: m{100pt} m{300pt}
-  .. cssclass:: toctableopencv
-
-  ==================  ============================================================================
-   |CreatingWidgets|   **Title:** :ref:`creating_widgets`
-
-                       *Compatibility:* > OpenCV 3.0.0
-
-                       *Author:* Ozan Tonkal
-
-                       You will learn how to create your own widgets.
-
-  ==================  ============================================================================
-
-  .. |CreatingWidgets| image:: ../creating_widgets/images/red_triangle.png
-                            :height: 120pt
-                            :width:  90pt
-
-.. raw:: latex
-
-   \pagebreak
-
-.. toctree::
-   :hidden:
-
-   ../launching_viz/launching_viz
-   ../widget_pose/widget_pose
-   ../transformations/transformations
-   ../creating_widgets/creating_widgets
@@ -1,202 +0,0 @@
-.. _transformations:
-
-Transformations
-***************
-
-Goal
-====
-
-In this tutorial you will learn how to
-
-.. container:: enumeratevisibleitemswithsquare
-
-  * How to use makeTransformToGlobal to compute pose
-  * How to use makeCameraPose and Viz3d::setViewerPose
-  * How to visualize camera position by axes and by viewing frustum
-
-Code
-====
-
-You can download the code from :download:`here <../../../../samples/cpp/tutorial_code/viz/transformations.cpp>`.
-
-.. code-block:: cpp
-
-    #include <opencv2/viz/vizcore.hpp>
-    #include <iostream>
-    #include <fstream>
-
-    using namespace cv;
-    using namespace std;
-
-    /**
-     * @function cvcloud_load
-     * @brief load bunny.ply
-     */
-    Mat cvcloud_load()
-    {
-        Mat cloud(1, 1889, CV_32FC3);
-        ifstream ifs("bunny.ply");
-
-        string str;
-        for(size_t i = 0; i < 12; ++i)
-            getline(ifs, str);
-
-        Point3f* data = cloud.ptr<cv::Point3f>();
-        float dummy1, dummy2;
-        for(size_t i = 0; i < 1889; ++i)
-            ifs >> data[i].x >> data[i].y >> data[i].z >> dummy1 >> dummy2;
-
-        cloud *= 5.0f;
-        return cloud;
-    }
-
-    /**
-     * @function main
-     */
-    int main(int argn, char **argv)
-    {
-        if (argn < 2)
-        {
-            cout << "Usage: " << endl << "./transformations [ G | C ]" << endl;
-            return 1;
-        }
-
-        bool camera_pov = (argv[1][0] == 'C');
-
-        /// Create a window
-        viz::Viz3d myWindow("Coordinate Frame");
-
-        /// Add coordinate axes
-        myWindow.showWidget("Coordinate Widget", viz::WCoordinateSystem());
-
-        /// Let's assume camera has the following properties
-        Point3f cam_pos(3.0f,3.0f,3.0f), cam_focal_point(3.0f,3.0f,2.0f), cam_y_dir(-1.0f,0.0f,0.0f);
-
-        /// We can get the pose of the cam using makeCameraPose
-        Affine3f cam_pose = viz::makeCameraPose(cam_pos, cam_focal_point, cam_y_dir);
-
-        /// We can get the transformation matrix from camera coordinate system to global using
-        /// - makeTransformToGlobal. We need the axes of the camera
-        Affine3f transform = viz::makeTransformToGlobal(Vec3f(0.0f,-1.0f,0.0f), Vec3f(-1.0f,0.0f,0.0f), Vec3f(0.0f,0.0f,-1.0f), cam_pos);
-
-        /// Create a cloud widget.
-        Mat bunny_cloud = cvcloud_load();
-        viz::WCloud cloud_widget(bunny_cloud, viz::Color::green());
-
-        /// Pose of the widget in camera frame
-        Affine3f cloud_pose = Affine3f().translate(Vec3f(0.0f,0.0f,3.0f));
-        /// Pose of the widget in global frame
-        Affine3f cloud_pose_global = transform * cloud_pose;
-
-        /// Visualize camera frame
-        if (!camera_pov)
-        {
-            viz::WCameraPosition cpw(0.5); // Coordinate axes
-            viz::WCameraPosition cpw_frustum(Vec2f(0.889484, 0.523599)); // Camera frustum
-            myWindow.showWidget("CPW", cpw, cam_pose);
-            myWindow.showWidget("CPW_FRUSTUM", cpw_frustum, cam_pose);
-        }
-
-        /// Visualize widget
-        myWindow.showWidget("bunny", cloud_widget, cloud_pose_global);
-
-        /// Set the viewer pose to that of camera
-        if (camera_pov)
-            myWindow.setViewerPose(cam_pose);
-
-        /// Start event loop.
-        myWindow.spin();
-
-        return 0;
-    }
-
-
-Explanation
-===========
-
-Here is the general structure of the program:
-
-* Create a visualization window.
-
-.. code-block:: cpp
-
-    /// Create a window
-    viz::Viz3d myWindow("Transformations");
-
-* Get camera pose from camera position, camera focal point and y direction.
-
-.. code-block:: cpp
-
-    /// Let's assume camera has the following properties
-    Point3f cam_pos(3.0f,3.0f,3.0f), cam_focal_point(3.0f,3.0f,2.0f), cam_y_dir(-1.0f,0.0f,0.0f);
-
-    /// We can get the pose of the cam using makeCameraPose
-    Affine3f cam_pose = viz::makeCameraPose(cam_pos, cam_focal_point, cam_y_dir);
-
-* Obtain transform matrix knowing the axes of camera coordinate system.
-
-.. code-block:: cpp
-
-    /// We can get the transformation matrix from camera coordinate system to global using
-    /// - makeTransformToGlobal. We need the axes of the camera
-    Affine3f transform = viz::makeTransformToGlobal(Vec3f(0.0f,-1.0f,0.0f), Vec3f(-1.0f,0.0f,0.0f), Vec3f(0.0f,0.0f,-1.0f), cam_pos);
-
-* Create a cloud widget from bunny.ply file
-
-.. code-block:: cpp
-
-    /// Create a cloud widget.
-    Mat bunny_cloud = cvcloud_load();
-    viz::WCloud cloud_widget(bunny_cloud, viz::Color::green());
-
-* Given the pose in camera coordinate system, estimate the global pose.
-
-.. code-block:: cpp
-
-    /// Pose of the widget in camera frame
-    Affine3f cloud_pose = Affine3f().translate(Vec3f(0.0f,0.0f,3.0f));
-    /// Pose of the widget in global frame
-    Affine3f cloud_pose_global = transform * cloud_pose;
-
-* If the view point is set to be global, visualize camera coordinate frame and viewing frustum.
-
-.. code-block:: cpp
-
-    /// Visualize camera frame
-    if (!camera_pov)
-    {
-        viz::WCameraPosition cpw(0.5); // Coordinate axes
-        viz::WCameraPosition cpw_frustum(Vec2f(0.889484, 0.523599)); // Camera frustum
-        myWindow.showWidget("CPW", cpw, cam_pose);
-        myWindow.showWidget("CPW_FRUSTUM", cpw_frustum, cam_pose);
-    }
-
-* Visualize the cloud widget with the estimated global pose
-
-.. code-block:: cpp
-
-    /// Visualize widget
-    myWindow.showWidget("bunny", cloud_widget, cloud_pose_global);
-
-* If the view point is set to be camera's, set viewer pose to **cam_pose**.
-
-.. code-block:: cpp
-
-    /// Set the viewer pose to that of camera
-    if (camera_pov)
-        myWindow.setViewerPose(cam_pose);
-
-Results
-=======
-
-#. Here is the result from the camera point of view.
-
-    .. image:: images/camera_view_point.png
-        :alt: Camera Viewpoint
-        :align: center
-
-#. Here is the result from global point of view.
-
-    .. image:: images/global_view_point.png
-        :alt: Global Viewpoint
-        :align: center
@@ -1,162 +0,0 @@
-.. _widget_pose:
-
-Pose of a widget
-****************
-
-Goal
-====
-
-In this tutorial you will learn how to
-
-.. container:: enumeratevisibleitemswithsquare
-
-  * Add widgets to the visualization window
-  * Use Affine3 to set pose of a widget
-  * Rotating and translating a widget along an axis
-
-Code
-====
-
-You can download the code from :download:`here <../../../../samples/cpp/tutorial_code/viz/widget_pose.cpp>`.
-
-.. code-block:: cpp
-
-    #include <opencv2/viz/vizcore.hpp>
-    #include <opencv2/calib3d/calib3d.hpp>
-    #include <iostream>
-
-    using namespace cv;
-    using namespace std;
-
-    /**
-     * @function main
-     */
-    int main()
-    {
-        /// Create a window
-        viz::Viz3d myWindow("Coordinate Frame");
-
-        /// Add coordinate axes
-        myWindow.showWidget("Coordinate Widget", viz::WCoordinateSystem());
-
-        /// Add line to represent (1,1,1) axis
-        viz::WLine axis(Point3f(-1.0f,-1.0f,-1.0f), Point3f(1.0f,1.0f,1.0f));
-        axis.setRenderingProperty(viz::LINE_WIDTH, 4.0);
-        myWindow.showWidget("Line Widget", axis);
-
-        /// Construct a cube widget
-        viz::WCube cube_widget(Point3f(0.5,0.5,0.0), Point3f(0.0,0.0,-0.5), true, viz::Color::blue());
-        cube_widget.setRenderingProperty(viz::LINE_WIDTH, 4.0);
-
-        /// Display widget (update if already displayed)
-        myWindow.showWidget("Cube Widget", cube_widget);
-
-        /// Rodrigues vector
-        Mat rot_vec = Mat::zeros(1,3,CV_32F);
-        float translation_phase = 0.0, translation = 0.0;
-        while(!myWindow.wasStopped())
-        {
-            /* Rotation using rodrigues */
-            /// Rotate around (1,1,1)
-            rot_vec.at<float>(0,0) += CV_PI * 0.01f;
-            rot_vec.at<float>(0,1) += CV_PI * 0.01f;
-            rot_vec.at<float>(0,2) += CV_PI * 0.01f;
-
-            /// Shift on (1,1,1)
-            translation_phase += CV_PI * 0.01f;
-            translation = sin(translation_phase);
-
-            Mat rot_mat;
-            Rodrigues(rot_vec, rot_mat);
-
-            /// Construct pose
-            Affine3f pose(rot_mat, Vec3f(translation, translation, translation));
-
-            myWindow.setWidgetPose("Cube Widget", pose);
-
-            myWindow.spinOnce(1, true);
-        }
-
-        return 0;
-    }
-
-Explanation
-===========
-
-Here is the general structure of the program:
-
-* Create a visualization window.
-
-.. code-block:: cpp
-
-    /// Create a window
-    viz::Viz3d myWindow("Coordinate Frame");
-
-* Show coordinate axes in the window using CoordinateSystemWidget.
-
-.. code-block:: cpp
-
-    /// Add coordinate axes
-    myWindow.showWidget("Coordinate Widget", viz::WCoordinateSystem());
-
-* Display a line representing the axis (1,1,1).
-
-.. code-block:: cpp
-
-    /// Add line to represent (1,1,1) axis
-    viz::WLine axis(Point3f(-1.0f,-1.0f,-1.0f), Point3f(1.0f,1.0f,1.0f));
-    axis.setRenderingProperty(viz::LINE_WIDTH, 4.0);
-    myWindow.showWidget("Line Widget", axis);
-
-* Construct a cube.
-
-.. code-block:: cpp
-
-    /// Construct a cube widget
-    viz::WCube cube_widget(Point3f(0.5,0.5,0.0), Point3f(0.0,0.0,-0.5), true, viz::Color::blue());
-    cube_widget.setRenderingProperty(viz::LINE_WIDTH, 4.0);
-    myWindow.showWidget("Cube Widget", cube_widget);
-
-* Create rotation matrix from rodrigues vector
-
-.. code-block:: cpp
-
-    /// Rotate around (1,1,1)
-    rot_vec.at<float>(0,0) += CV_PI * 0.01f;
-    rot_vec.at<float>(0,1) += CV_PI * 0.01f;
-    rot_vec.at<float>(0,2) += CV_PI * 0.01f;
-
-    ...
-
-    Mat rot_mat;
-    Rodrigues(rot_vec, rot_mat);
-
-* Use Affine3f to set pose of the cube.
-
-.. code-block:: cpp
-
-    /// Construct pose
-    Affine3f pose(rot_mat, Vec3f(translation, translation, translation));
-    myWindow.setWidgetPose("Cube Widget", pose);
-
-* Animate the rotation using wasStopped and spinOnce
-
-.. code-block:: cpp
-
-    while(!myWindow.wasStopped())
-    {
-        ...
-
-        myWindow.spinOnce(1, true);
-    }
-
-Results
-=======
-
-Here is the result of the program.
-
-.. raw:: html
-
-  <div align="center">
-  <iframe width="420" height="315" src="https://www.youtube.com/embed/22HKMN657U0" frameborder="0" allowfullscreen></iframe>
-  </div>
@@ -58,7 +58,7 @@ SET_TARGET_PROPERTIES(${the_target} PROPERTIES
                      RUNTIME_OUTPUT_DIRECTORY ${EXECUTABLE_OUTPUT_PATH}
                      )

-if (NOT (CMAKE_BUILD_TYPE MATCHES "Debug"))
+if (NOT (CMAKE_BUILD_TYPE MATCHES "debug"))
    ADD_CUSTOM_COMMAND( TARGET ${the_target} POST_BUILD COMMAND ${CMAKE_STRIP} --strip-unneeded "${LIBRARY_OUTPUT_PATH}/lib${the_target}.so" )
 endif()

@@ -61,12 +61,6 @@

 using namespace android;

-// non-public camera related classes are not binary compatible
-// objects of these classes have different sizeof on different platforms
-// additional memory tail to all system objects to overcome sizeof issue
-#define MAGIC_TAIL 4096
-
-
 void debugShowFPS();

 #if defined(ANDROID_r4_1_1) || defined(ANDROID_r4_2_0) || defined(ANDROID_r4_3_0)
@@ -96,7 +90,6 @@ public:
 };
 #endif

-
 std::string getProcessName()
 {
    std::string result;
@@ -149,22 +142,12 @@ class CameraHandler: public CameraListener
 protected:
    int cameraId;
    sp<Camera> camera;
-#if defined(ANDROID_r3_0_1) || defined(ANDROID_r4_0_0) || defined(ANDROID_r4_0_3)
-    sp<SurfaceTexture> surface;
-#endif
-#if defined(ANDROID_r4_1_1) || defined(ANDROID_r4_2_0) || defined(ANDROID_r4_3_0) || defined(ANDROID_r4_4_0)
-    sp<BufferQueue> queue;
-    sp<ConsumerListenerStub> listener;
-#endif
-    CameraParameters* params;
+    CameraParameters params;
    CameraCallback cameraCallback;
    void* userData;

    int emptyCameraCallbackReported;

-    int width;
-    int height;
-
    static const char* flashModesNames[ANDROID_CAMERA_FLASH_MODES_NUM];
    static const char* focusModesNames[ANDROID_CAMERA_FOCUS_MODES_NUM];
    static const char* whiteBalanceModesNames[ANDROID_CAMERA_WHITE_BALANCE_MODES_NUM];
@@ -275,7 +258,7 @@ protected:

    int is_supported(const char* supp_modes_key, const char* mode)
    {
-        const char* supported_modes = params->get(supp_modes_key);
+        const char* supported_modes = params.get(supp_modes_key);
        return (supported_modes && mode && (strstr(supported_modes, mode) > 0));
    }

@@ -285,7 +268,7 @@ protected:
        if (focus_distance_type >= 0 && focus_distance_type < 3)
    {
            float focus_distances[3];
-            const char* output = params->get(CameraParameters::KEY_FOCUS_DISTANCES);
+            const char* output = params.get(CameraParameters::KEY_FOCUS_DISTANCES);
            int val_num = CameraHandler::split_float(output, focus_distances, ',', 3);
            if(val_num == 3)
        {
@@ -317,15 +300,10 @@ public:
        emptyCameraCallbackReported(0)
    {
        LOGD("Instantiated new CameraHandler (%p, %p)", callback, _userData);
-        void* params_buffer = operator new(sizeof(CameraParameters) + MAGIC_TAIL);
-        params = new(params_buffer) CameraParameters();
    }

    virtual ~CameraHandler()
    {
-        if (params)
-            params->~CameraParameters();
-            operator delete(params);
        LOGD("CameraHandler destructor is called");
    }

@@ -393,18 +371,10 @@ const char* CameraHandler::focusModesNames[ANDROID_CAMERA_FOCUS_MODES_NUM] =
    CameraParameters::FOCUS_MODE_AUTO,
 #if !defined(ANDROID_r2_2_0)
    CameraParameters::FOCUS_MODE_CONTINUOUS_VIDEO,
-#else
-    CameraParameters::FOCUS_MODE_AUTO,
 #endif
    CameraParameters::FOCUS_MODE_EDOF,
    CameraParameters::FOCUS_MODE_FIXED,
-    CameraParameters::FOCUS_MODE_INFINITY,
-    CameraParameters::FOCUS_MODE_MACRO,
-#if !defined(ANDROID_r2_2_0) && !defined(ANDROID_r2_3_3) && !defined(ANDROID_r3_0_1)
-    CameraParameters::FOCUS_MODE_CONTINUOUS_PICTURE
-#else
-    CameraParameters::FOCUS_MODE_AUTO
-#endif
+    CameraParameters::FOCUS_MODE_INFINITY
 };

 const char* CameraHandler::whiteBalanceModesNames[ANDROID_CAMERA_WHITE_BALANCE_MODES_NUM] =
@@ -564,39 +534,39 @@ CameraHandler* CameraHandler::initCameraConnect(const CameraCallback& callback,
    {
        LOGI("initCameraConnect: Setting paramers from previous camera handler");
        camera->setParameters(prevCameraParameters->flatten());
-        handler->params->unflatten(prevCameraParameters->flatten());
+        handler->params.unflatten(prevCameraParameters->flatten());
    }
    else
    {
        android::String8 params_str = camera->getParameters();
        LOGI("initCameraConnect: [%s]", params_str.string());

-        handler->params->unflatten(params_str);
+        handler->params.unflatten(params_str);

-        LOGD("Supported Cameras: %s", handler->params->get("camera-indexes"));
-        LOGD("Supported Picture Sizes: %s", handler->params->get(CameraParameters::KEY_SUPPORTED_PICTURE_SIZES));
-        LOGD("Supported Picture Formats: %s", handler->params->get(CameraParameters::KEY_SUPPORTED_PICTURE_FORMATS));
-        LOGD("Supported Preview Sizes: %s", handler->params->get(CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES));
-        LOGD("Supported Preview Formats: %s", handler->params->get(CameraParameters::KEY_SUPPORTED_PREVIEW_FORMATS));
-        LOGD("Supported Preview Frame Rates: %s", handler->params->get(CameraParameters::KEY_SUPPORTED_PREVIEW_FRAME_RATES));
-        LOGD("Supported Thumbnail Sizes: %s", handler->params->get(CameraParameters::KEY_SUPPORTED_JPEG_THUMBNAIL_SIZES));
-        LOGD("Supported Whitebalance Modes: %s", handler->params->get(CameraParameters::KEY_SUPPORTED_WHITE_BALANCE));
-        LOGD("Supported Effects: %s", handler->params->get(CameraParameters::KEY_SUPPORTED_EFFECTS));
-        LOGD("Supported Scene Modes: %s", handler->params->get(CameraParameters::KEY_SUPPORTED_SCENE_MODES));
-        LOGD("Supported Focus Modes: %s", handler->params->get(CameraParameters::KEY_SUPPORTED_FOCUS_MODES));
-        LOGD("Supported Antibanding Options: %s", handler->params->get(CameraParameters::KEY_SUPPORTED_ANTIBANDING));
-        LOGD("Supported Flash Modes: %s", handler->params->get(CameraParameters::KEY_SUPPORTED_FLASH_MODES));
+        LOGD("Supported Cameras: %s", handler->params.get("camera-indexes"));
+        LOGD("Supported Picture Sizes: %s", handler->params.get(CameraParameters::KEY_SUPPORTED_PICTURE_SIZES));
+        LOGD("Supported Picture Formats: %s", handler->params.get(CameraParameters::KEY_SUPPORTED_PICTURE_FORMATS));
+        LOGD("Supported Preview Sizes: %s", handler->params.get(CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES));
+        LOGD("Supported Preview Formats: %s", handler->params.get(CameraParameters::KEY_SUPPORTED_PREVIEW_FORMATS));
+        LOGD("Supported Preview Frame Rates: %s", handler->params.get(CameraParameters::KEY_SUPPORTED_PREVIEW_FRAME_RATES));
+        LOGD("Supported Thumbnail Sizes: %s", handler->params.get(CameraParameters::KEY_SUPPORTED_JPEG_THUMBNAIL_SIZES));
+        LOGD("Supported Whitebalance Modes: %s", handler->params.get(CameraParameters::KEY_SUPPORTED_WHITE_BALANCE));
+        LOGD("Supported Effects: %s", handler->params.get(CameraParameters::KEY_SUPPORTED_EFFECTS));
+        LOGD("Supported Scene Modes: %s", handler->params.get(CameraParameters::KEY_SUPPORTED_SCENE_MODES));
+        LOGD("Supported Focus Modes: %s", handler->params.get(CameraParameters::KEY_SUPPORTED_FOCUS_MODES));
+        LOGD("Supported Antibanding Options: %s", handler->params.get(CameraParameters::KEY_SUPPORTED_ANTIBANDING));
+        LOGD("Supported Flash Modes: %s", handler->params.get(CameraParameters::KEY_SUPPORTED_FLASH_MODES));

 #if !defined(ANDROID_r2_2_0)
        // Set focus mode to continuous-video if supported
-        const char* available_focus_modes = handler->params->get(CameraParameters::KEY_SUPPORTED_FOCUS_MODES);
+        const char* available_focus_modes = handler->params.get(CameraParameters::KEY_SUPPORTED_FOCUS_MODES);
        if (available_focus_modes != 0)
        {
            if (strstr(available_focus_modes, "continuous-video") != NULL)
            {
-                handler->params->set(CameraParameters::KEY_FOCUS_MODE, CameraParameters::FOCUS_MODE_CONTINUOUS_VIDEO);
+                handler->params.set(CameraParameters::KEY_FOCUS_MODE, CameraParameters::FOCUS_MODE_CONTINUOUS_VIDEO);

-                status_t resParams = handler->camera->setParameters(handler->params->flatten());
+                status_t resParams = handler->camera->setParameters(handler->params.flatten());

                if (resParams != 0)
                {
@@ -611,7 +581,7 @@ CameraHandler* CameraHandler::initCameraConnect(const CameraCallback& callback,
 #endif

        //check if yuv420sp format available. Set this format as preview format.
-        const char* available_formats = handler->params->get(CameraParameters::KEY_SUPPORTED_PREVIEW_FORMATS);
+        const char* available_formats = handler->params.get(CameraParameters::KEY_SUPPORTED_PREVIEW_FORMATS);
        if (available_formats != 0)
        {
            const char* format_to_set = 0;
@@ -637,9 +607,9 @@ CameraHandler* CameraHandler::initCameraConnect(const CameraCallback& callback,

            if (0 != format_to_set)
            {
-                handler->params->setPreviewFormat(format_to_set);
+                handler->params.setPreviewFormat(format_to_set);

-                status_t resParams = handler->camera->setParameters(handler->params->flatten());
+                status_t resParams = handler->camera->setParameters(handler->params.flatten());

                if (resParams != 0)
                    LOGE("initCameraConnect: failed to set preview format to %s", format_to_set);
@@ -647,13 +617,6 @@ CameraHandler* CameraHandler::initCameraConnect(const CameraCallback& callback,
                    LOGD("initCameraConnect: preview format is set to %s", format_to_set);
            }
        }
-
-        handler->params->setPreviewSize(640, 480);
-        status_t resParams = handler->camera->setParameters(handler->params->flatten());
-        if (resParams != 0)
-            LOGE("initCameraConnect: failed to set preview resolution to 640x480");
-        else
-            LOGD("initCameraConnect: preview format is set to 640x480");
    }

    status_t bufferStatus;
@@ -664,27 +627,22 @@ CameraHandler* CameraHandler::initCameraConnect(const CameraCallback& callback,
 #elif defined(ANDROID_r2_3_3)
    /* Do nothing in case of 2.3 for now */
 #elif defined(ANDROID_r3_0_1) || defined(ANDROID_r4_0_0) || defined(ANDROID_r4_0_3)
-    void* surface_texture_obj = operator new(sizeof(SurfaceTexture) + MAGIC_TAIL);
-    handler->surface = new(surface_texture_obj) SurfaceTexture(MAGIC_OPENCV_TEXTURE_ID);
-    bufferStatus = camera->setPreviewTexture(handler->surface);
+    sp<SurfaceTexture> surfaceTexture = new SurfaceTexture(MAGIC_OPENCV_TEXTURE_ID);
+    bufferStatus = camera->setPreviewTexture(surfaceTexture);
    if (bufferStatus != 0)
        LOGE("initCameraConnect: failed setPreviewTexture call (status %d); camera might not work correctly", bufferStatus);
 #elif defined(ANDROID_r4_1_1) || defined(ANDROID_r4_2_0) || defined(ANDROID_r4_3_0)
-    void* buffer_queue_obj = operator new(sizeof(BufferQueue) + MAGIC_TAIL);
-    handler->queue = new(buffer_queue_obj) BufferQueue();
-    void* consumer_listener_obj = operator new(sizeof(ConsumerListenerStub) + MAGIC_TAIL);
-    handler->listener = new(consumer_listener_obj) ConsumerListenerStub();
-    handler->queue->consumerConnect(handler->listener);
-    bufferStatus = camera->setPreviewTexture(handler->queue);
+    sp<BufferQueue> bufferQueue = new BufferQueue();
+    sp<BufferQueue::ConsumerListener> queueListener = new ConsumerListenerStub();
+    bufferQueue->consumerConnect(queueListener);
+    bufferStatus = camera->setPreviewTexture(bufferQueue);
    if (bufferStatus != 0)
        LOGE("initCameraConnect: failed setPreviewTexture call; camera might not work correctly");
 # elif defined(ANDROID_r4_4_0)
-    void* buffer_queue_obj = operator new(sizeof(BufferQueue) + MAGIC_TAIL);
-    handler->queue = new(buffer_queue_obj) BufferQueue();
-    void* consumer_listener_obj = operator new(sizeof(ConsumerListenerStub) + MAGIC_TAIL);
-    handler->listener = new(consumer_listener_obj) ConsumerListenerStub();
-    handler->queue->consumerConnect(handler->listener, true);
-    bufferStatus = handler->camera->setPreviewTarget(handler->queue);
+    sp<BufferQueue> bufferQueue = new BufferQueue();
+    sp<IConsumerListener> queueListener = new ConsumerListenerStub();
+    bufferQueue->consumerConnect(queueListener, true);
+    bufferStatus = handler->camera->setPreviewTarget(bufferQueue);
    if (bufferStatus != 0)
        LOGE("applyProperties: failed setPreviewTexture call; camera might not work correctly");
 # endif
@@ -765,18 +723,18 @@ double CameraHandler::getProperty(int propIdx)
    case ANDROID_CAMERA_PROPERTY_FRAMEWIDTH:
    {
        int w,h;
-        params->getPreviewSize(&w, &h);
+        params.getPreviewSize(&w, &h);
        return w;
    }
    case ANDROID_CAMERA_PROPERTY_FRAMEHEIGHT:
    {
        int w,h;
-        params->getPreviewSize(&w, &h);
+        params.getPreviewSize(&w, &h);
        return h;
    }
    case ANDROID_CAMERA_PROPERTY_SUPPORTED_PREVIEW_SIZES_STRING:
    {
-        cameraPropertySupportedPreviewSizesString = params->get(CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES);
+        cameraPropertySupportedPreviewSizesString = params.get(CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES);
        union {const char* str;double res;} u;
        memset(&u.res, 0, sizeof(u.res));
        u.str = cameraPropertySupportedPreviewSizesString.c_str();
@@ -784,7 +742,7 @@ double CameraHandler::getProperty(int propIdx)
    }
    case ANDROID_CAMERA_PROPERTY_PREVIEW_FORMAT_STRING:
    {
-        const char* fmt = params->get(CameraParameters::KEY_PREVIEW_FORMAT);
+        const char* fmt = params.get(CameraParameters::KEY_PREVIEW_FORMAT);
        if (fmt == CameraParameters::PIXEL_FORMAT_YUV422SP)
            fmt = "yuv422sp";
        else if (fmt == CameraParameters::PIXEL_FORMAT_YUV420SP)
@@ -804,44 +762,44 @@ double CameraHandler::getProperty(int propIdx)
    }
    case ANDROID_CAMERA_PROPERTY_EXPOSURE:
    {
-        int exposure = params->getInt(CameraParameters::KEY_EXPOSURE_COMPENSATION);
+        int exposure = params.getInt(CameraParameters::KEY_EXPOSURE_COMPENSATION);
        return exposure;
    }
    case ANDROID_CAMERA_PROPERTY_FPS:
    {
-        return params->getPreviewFrameRate();
+        return params.getPreviewFrameRate();
    }
    case ANDROID_CAMERA_PROPERTY_FLASH_MODE:
    {
        int flash_mode = getModeNum(CameraHandler::flashModesNames,
                                    ANDROID_CAMERA_FLASH_MODES_NUM,
-                                    params->get(CameraParameters::KEY_FLASH_MODE));
+                                    params.get(CameraParameters::KEY_FLASH_MODE));
        return flash_mode;
    }
    case ANDROID_CAMERA_PROPERTY_FOCUS_MODE:
    {
        int focus_mode = getModeNum(CameraHandler::focusModesNames,
                                    ANDROID_CAMERA_FOCUS_MODES_NUM,
-                                    params->get(CameraParameters::KEY_FOCUS_MODE));
+                                    params.get(CameraParameters::KEY_FOCUS_MODE));
        return focus_mode;
    }
    case ANDROID_CAMERA_PROPERTY_WHITE_BALANCE:
    {
        int white_balance = getModeNum(CameraHandler::whiteBalanceModesNames,
                                       ANDROID_CAMERA_WHITE_BALANCE_MODES_NUM,
-                                       params->get(CameraParameters::KEY_WHITE_BALANCE));
+                                       params.get(CameraParameters::KEY_WHITE_BALANCE));
        return white_balance;
    }
    case ANDROID_CAMERA_PROPERTY_ANTIBANDING:
    {
        int antibanding = getModeNum(CameraHandler::antibandingModesNames,
                                     ANDROID_CAMERA_ANTIBANDING_MODES_NUM,
-                                     params->get(CameraParameters::KEY_ANTIBANDING));
+                                     params.get(CameraParameters::KEY_ANTIBANDING));
        return antibanding;
    }
    case ANDROID_CAMERA_PROPERTY_FOCAL_LENGTH:
    {
-        float focal_length = params->getFloat(CameraParameters::KEY_FOCAL_LENGTH);
+        float focal_length = params.getFloat(CameraParameters::KEY_FOCAL_LENGTH);
        return focal_length;
    }
    case ANDROID_CAMERA_PROPERTY_FOCUS_DISTANCE_NEAR:
@@ -856,24 +814,6 @@ double CameraHandler::getProperty(int propIdx)
    {
        return getFocusDistance(ANDROID_CAMERA_FOCUS_DISTANCE_FAR_INDEX);
    }
-#if !defined(ANDROID_r2_2_0) && !defined(ANDROID_r2_3_3) && !defined(ANDROID_r3_0_1)
-    case ANDROID_CAMERA_PROPERTY_WHITEBALANCE_LOCK:
-    {
-        const char* status = params->get(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK);
-        if (status == CameraParameters::TRUE)
-            return 1.;
-        else
-            return 0.;
-    }
-    case ANDROID_CAMERA_PROPERTY_EXPOSE_LOCK:
-    {
-        const char* status = params->get(CameraParameters::KEY_AUTO_EXPOSURE_LOCK);
-        if (status == CameraParameters::TRUE)
-            return 1.;
-        else
-            return 0.;
-    }
-#endif
    default:
        LOGW("CameraHandler::getProperty - Unsupported property.");
    };
@@ -884,151 +824,99 @@ void CameraHandler::setProperty(int propIdx, double value)
 {
    LOGD("CameraHandler::setProperty(%d, %f)", propIdx, value);

-    android::String8 params_str;
-    params_str = camera->getParameters();
-    LOGI("Params before set: [%s]", params_str.string());
-
    switch (propIdx)
    {
    case ANDROID_CAMERA_PROPERTY_FRAMEWIDTH:
    {
        int w,h;
-        params->getPreviewSize(&w, &h);
-        width = (int)value;
+        params.getPreviewSize(&w, &h);
+        w = (int)value;
+        params.setPreviewSize(w, h);
    }
    break;
    case ANDROID_CAMERA_PROPERTY_FRAMEHEIGHT:
    {
        int w,h;
-        params->getPreviewSize(&w, &h);
-        height = (int)value;
+        params.getPreviewSize(&w, &h);
+        h = (int)value;
+        params.setPreviewSize(w, h);
    }
    break;
    case ANDROID_CAMERA_PROPERTY_EXPOSURE:
    {
-        int max_exposure = params->getInt("max-exposure-compensation");
-        int min_exposure = params->getInt("min-exposure-compensation");
-        if(max_exposure && min_exposure)
-        {
+        int max_exposure = params.getInt("max-exposure-compensation");
+        int min_exposure = params.getInt("min-exposure-compensation");
+        if(max_exposure && min_exposure){
            int exposure = (int)value;
-            if(exposure >= min_exposure && exposure <= max_exposure)
-                params->set("exposure-compensation", exposure);
-            else
+            if(exposure >= min_exposure && exposure <= max_exposure){
+                params.set("exposure-compensation", exposure);
+            } else {
                LOGE("Exposure compensation not in valid range (%i,%i).", min_exposure, max_exposure);
-        } else
+            }
+        } else {
            LOGE("Exposure compensation adjust is not supported.");
-
-        camera->setParameters(params->flatten());
+        }
    }
    break;
    case ANDROID_CAMERA_PROPERTY_FLASH_MODE:
    {
        int new_val = (int)value;
-        if(new_val >= 0 && new_val < ANDROID_CAMERA_FLASH_MODES_NUM)
-        {
+        if(new_val >= 0 && new_val < ANDROID_CAMERA_FLASH_MODES_NUM){
            const char* mode_name = flashModesNames[new_val];
            if(is_supported(CameraParameters::KEY_SUPPORTED_FLASH_MODES, mode_name))
-                params->set(CameraParameters::KEY_FLASH_MODE, mode_name);
+                params.set(CameraParameters::KEY_FLASH_MODE, mode_name);
            else
                LOGE("Flash mode %s is not supported.", mode_name);
-        }
-        else
+        } else {
            LOGE("Flash mode value not in valid range.");
-
-        camera->setParameters(params->flatten());
+        }
    }
    break;
    case ANDROID_CAMERA_PROPERTY_FOCUS_MODE:
    {
        int new_val = (int)value;
-        if(new_val >= 0 && new_val < ANDROID_CAMERA_FOCUS_MODES_NUM)
-        {
+        if(new_val >= 0 && new_val < ANDROID_CAMERA_FOCUS_MODES_NUM){
            const char* mode_name = focusModesNames[new_val];
            if(is_supported(CameraParameters::KEY_SUPPORTED_FOCUS_MODES, mode_name))
-                params->set(CameraParameters::KEY_FOCUS_MODE, mode_name);
+                params.set(CameraParameters::KEY_FOCUS_MODE, mode_name);
            else
                LOGE("Focus mode %s is not supported.", mode_name);
-        }
-        else
+        } else {
            LOGE("Focus mode value not in valid range.");
-
-        camera->setParameters(params->flatten());
+        }
    }
    break;
    case ANDROID_CAMERA_PROPERTY_WHITE_BALANCE:
    {
        int new_val = (int)value;
-        if(new_val >= 0 && new_val < ANDROID_CAMERA_WHITE_BALANCE_MODES_NUM)
-        {
+        if(new_val >= 0 && new_val < ANDROID_CAMERA_WHITE_BALANCE_MODES_NUM){
            const char* mode_name = whiteBalanceModesNames[new_val];
            if(is_supported(CameraParameters::KEY_SUPPORTED_WHITE_BALANCE, mode_name))
-                params->set(CameraParameters::KEY_WHITE_BALANCE, mode_name);
+                params.set(CameraParameters::KEY_WHITE_BALANCE, mode_name);
            else
                LOGE("White balance mode %s is not supported.", mode_name);
-        }
-        else
+        } else {
            LOGE("White balance mode value not in valid range.");
-
-        camera->setParameters(params->flatten());
+        }
    }
    break;
    case ANDROID_CAMERA_PROPERTY_ANTIBANDING:
    {
        int new_val = (int)value;
-        if(new_val >= 0 && new_val < ANDROID_CAMERA_ANTIBANDING_MODES_NUM)
-        {
+        if(new_val >= 0 && new_val < ANDROID_CAMERA_ANTIBANDING_MODES_NUM){
            const char* mode_name = antibandingModesNames[new_val];
            if(is_supported(CameraParameters::KEY_SUPPORTED_ANTIBANDING, mode_name))
-                params->set(CameraParameters::KEY_ANTIBANDING, mode_name);
+                params.set(CameraParameters::KEY_ANTIBANDING, mode_name);
            else
                LOGE("Antibanding mode %s is not supported.", mode_name);
-        }
-        else
+        } else {
            LOGE("Antibanding mode value not in valid range.");
-
-        camera->setParameters(params->flatten());
-    }
-    break;
-#if !defined(ANDROID_r2_2_0) && !defined(ANDROID_r2_3_3) && !defined(ANDROID_r3_0_1)
-    case ANDROID_CAMERA_PROPERTY_EXPOSE_LOCK:
-    {
-        if (is_supported(CameraParameters::KEY_AUTO_EXPOSURE_LOCK_SUPPORTED, "true"))
-        {
-            if (value != 0)
-                params->set(CameraParameters::KEY_AUTO_EXPOSURE_LOCK, CameraParameters::TRUE);
-            else
-                params->set(CameraParameters::KEY_AUTO_EXPOSURE_LOCK, CameraParameters::FALSE);
-            LOGE("Expose lock is set");
        }
-        else
-            LOGE("Expose lock is not supported");
-
-        camera->setParameters(params->flatten());
    }
    break;
-    case ANDROID_CAMERA_PROPERTY_WHITEBALANCE_LOCK:
-    {
-        if (is_supported(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK_SUPPORTED, "true"))
-        {
-            if (value != 0)
-                params->set(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK, CameraParameters::TRUE);
-            else
-                params->set(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK, CameraParameters::FALSE);
-            LOGE("White balance lock is set");
-        }
-        else
-            LOGE("White balance lock is not supported");
-
-        camera->setParameters(params->flatten());
-    }
-    break;
-#endif
    default:
        LOGW("CameraHandler::setProperty - Unsupported property.");
    };
-
-    params_str = camera->getParameters();
-    LOGI("Params after set: [%s]", params_str.string());
 }

 void CameraHandler::applyProperties(CameraHandler** ppcameraHandler)
@@ -1047,10 +935,7 @@ void CameraHandler::applyProperties(CameraHandler** ppcameraHandler)
        return;
    }

-    // delayed resolution setup to exclude errors during other parameres setup on the fly
-    // without camera restart
-    if (((*ppcameraHandler)->width != 0) && ((*ppcameraHandler)->height != 0))
-        (*ppcameraHandler)->params->setPreviewSize((*ppcameraHandler)->width, (*ppcameraHandler)->height);
+    CameraParameters curCameraParameters((*ppcameraHandler)->params.flatten());

 #if defined(ANDROID_r4_0_0) || defined(ANDROID_r4_0_3) || defined(ANDROID_r4_1_1) || defined(ANDROID_r4_2_0) \
 || defined(ANDROID_r4_3_0) || defined(ANDROID_r4_4_0)
@@ -1066,27 +951,27 @@ void CameraHandler::applyProperties(CameraHandler** ppcameraHandler)
        return;
    }

-    handler->camera->setParameters((*ppcameraHandler)->params->flatten());
+    handler->camera->setParameters(curCameraParameters.flatten());
+    handler->params.unflatten(curCameraParameters.flatten());

    status_t bufferStatus;
 # if defined(ANDROID_r4_0_0) || defined(ANDROID_r4_0_3)
-    void* surface_texture_obj = operator new(sizeof(SurfaceTexture) + MAGIC_TAIL);
-    handler->surface = new(surface_texture_obj) SurfaceTexture(MAGIC_OPENCV_TEXTURE_ID);
-    bufferStatus = handler->camera->setPreviewTexture(handler->surface);
+    sp<SurfaceTexture> surfaceTexture = new SurfaceTexture(MAGIC_OPENCV_TEXTURE_ID);
+    bufferStatus = handler->camera->setPreviewTexture(surfaceTexture);
    if (bufferStatus != 0)
        LOGE("applyProperties: failed setPreviewTexture call (status %d); camera might not work correctly", bufferStatus);
 # elif defined(ANDROID_r4_1_1) || defined(ANDROID_r4_2_0) || defined(ANDROID_r4_3_0)
-    void* buffer_queue_obj = operator new(sizeof(BufferQueue) + MAGIC_TAIL);
-    handler->queue = new(buffer_queue_obj) BufferQueue();
-    handler->queue->consumerConnect(handler->listener);
-    bufferStatus = handler->camera->setPreviewTexture(handler->queue);
+    sp<BufferQueue> bufferQueue = new BufferQueue();
+    sp<BufferQueue::ConsumerListener> queueListener = new ConsumerListenerStub();
+    bufferQueue->consumerConnect(queueListener);
+    bufferStatus = handler->camera->setPreviewTexture(bufferQueue);
    if (bufferStatus != 0)
        LOGE("applyProperties: failed setPreviewTexture call; camera might not work correctly");
 # elif defined(ANDROID_r4_4_0)
-    void* buffer_queue_obj = operator new(sizeof(BufferQueue) + MAGIC_TAIL);
-    handler->queue = new(buffer_queue_obj) BufferQueue();
-    handler->queue->consumerConnect(handler->listener, true);
-    bufferStatus = handler->camera->setPreviewTarget(handler->queue);
+    sp<BufferQueue> bufferQueue = new BufferQueue();
+    sp<IConsumerListener> queueListener = new ConsumerListenerStub();
+    bufferQueue->consumerConnect(queueListener, true);
+    bufferStatus = handler->camera->setPreviewTarget(bufferQueue);
    if (bufferStatus != 0)
        LOGE("applyProperties: failed setPreviewTexture call; camera might not work correctly");
 # endif
@@ -1117,7 +1002,7 @@ void CameraHandler::applyProperties(CameraHandler** ppcameraHandler)
    LOGD("CameraHandler::applyProperties(): after previousCameraHandler->closeCameraConnect");

    LOGD("CameraHandler::applyProperties(): before initCameraConnect");
-    CameraHandler* handler=initCameraConnect(cameraCallback, cameraId, userData, (*ppcameraHandler)->params);
+    CameraHandler* handler=initCameraConnect(cameraCallback, cameraId, userData, &curCameraParameters);
    LOGD("CameraHandler::applyProperties(): after initCameraConnect, handler=0x%x", (int)handler);
    if (handler == NULL) {
        LOGE("ERROR in applyProperties --- cannot reinit camera");
@@ -15,9 +15,7 @@ enum {
    ANDROID_CAMERA_PROPERTY_FOCAL_LENGTH = 105,
    ANDROID_CAMERA_PROPERTY_FOCUS_DISTANCE_NEAR = 106,
    ANDROID_CAMERA_PROPERTY_FOCUS_DISTANCE_OPTIMAL = 107,
-    ANDROID_CAMERA_PROPERTY_FOCUS_DISTANCE_FAR = 108,
-    ANDROID_CAMERA_PROPERTY_EXPOSE_LOCK = 109,
-    ANDROID_CAMERA_PROPERTY_WHITEBALANCE_LOCK = 110
+    ANDROID_CAMERA_PROPERTY_FOCUS_DISTANCE_FAR = 108
 };


@@ -32,12 +30,12 @@ enum {

 enum {
    ANDROID_CAMERA_FOCUS_MODE_AUTO = 0,
+    ANDROID_CAMERA_FOCUS_MODE_CONTINUOUS_PICTURE,
    ANDROID_CAMERA_FOCUS_MODE_CONTINUOUS_VIDEO,
    ANDROID_CAMERA_FOCUS_MODE_EDOF,
    ANDROID_CAMERA_FOCUS_MODE_FIXED,
    ANDROID_CAMERA_FOCUS_MODE_INFINITY,
    ANDROID_CAMERA_FOCUS_MODE_MACRO,
-    ANDROID_CAMERA_FOCUS_MODE_CONTINUOUS_PICTURE,
    ANDROID_CAMERA_FOCUS_MODES_NUM
 };

@@ -126,7 +126,7 @@ PERF_TEST_P(PointsNum, DISABLED_SolvePnPRansac, testing::Values(4, 3*9, 7*13))
    Mat tvec;

 #ifdef HAVE_TBB
-    // limit concurrency to get deterministic result
+    // limit concurrency to get determenistic result
    cv::Ptr<tbb::task_scheduler_init> one_thread = new tbb::task_scheduler_init(1);
 #endif

@@ -478,7 +478,7 @@ void CV_CameraCalibrationTest::run( int start_from )
        values_read = fscanf(file,"%lf",goodDistortion+2); CV_Assert(values_read == 1);
        values_read = fscanf(file,"%lf",goodDistortion+3); CV_Assert(values_read == 1);

-        /* Read good Rot matrices */
+        /* Read good Rot matrixes */
        for( currImage = 0; currImage < numImages; currImage++ )
        {
            for( i = 0; i < 3; i++ )
@@ -1605,7 +1605,7 @@ void CV_StereoCalibrationTest::run( int )
        Mat _M1, _M2, _D1, _D2;
        vector<Mat> _R1, _R2, _T1, _T2;
        calibrateCamera( objpt, imgpt1, imgsize, _M1, _D1, _R1, _T1, 0 );
-        calibrateCamera( objpt, imgpt2, imgsize, _M2, _D2, _R2, _T2, 0 );
+        calibrateCamera( objpt, imgpt2, imgsize, _M2, _D2, _R2, _T1, 0 );
        undistortPoints( _imgpt1, _imgpt1, _M1, _D1, Mat(), _M1 );
        undistortPoints( _imgpt2, _imgpt2, _M2, _D2, Mat(), _M2 );

@@ -34,7 +34,7 @@ private:
    Mat rvec, tvec;
 };

-}
+};


 #endif
@@ -271,7 +271,7 @@ TEST(DISABLED_Calib3d_SolvePnPRansac, concurrency)
    Mat tvec1, tvec2;

    {
-        // limit concurrency to get deterministic result
+        // limit concurrency to get determenistic result
        cv::theRNG().state = 20121010;
        cv::Ptr<tbb::task_scheduler_init> one_thread = new tbb::task_scheduler_init(1);
        solvePnPRansac(object, image, camera_mat, dist_coef, rvec1, tvec1);
@@ -75,7 +75,7 @@ Moreover every :ocv:class:`FaceRecognizer` supports the:
 Setting the Thresholds
 +++++++++++++++++++++++

-Sometimes you run into the situation, when you want to apply a threshold on the prediction. A common scenario in face recognition is to tell, whether a face belongs to the training dataset or if it is unknown. You might wonder, why there's no public API in :ocv:class:`FaceRecognizer` to set the threshold for the prediction, but rest assured: It's supported. It just means there's no generic way in an abstract class to provide an interface for setting/getting the thresholds of *every possible* :ocv:class:`FaceRecognizer` algorithm. The appropriate place to set the thresholds is in the constructor of the specific :ocv:class:`FaceRecognizer` and since every :ocv:class:`FaceRecognizer` is a :ocv:class:`Algorithm` (see above), you can get/set the thresholds at runtime!
+Sometimes you run into the situation, when you want to apply a threshold on the prediction. A common scenario in face recognition is to tell, wether a face belongs to the training dataset or if it is unknown. You might wonder, why there's no public API in :ocv:class:`FaceRecognizer` to set the threshold for the prediction, but rest assured: It's supported. It just means there's no generic way in an abstract class to provide an interface for setting/getting the thresholds of *every possible* :ocv:class:`FaceRecognizer` algorithm. The appropriate place to set the thresholds is in the constructor of the specific :ocv:class:`FaceRecognizer` and since every :ocv:class:`FaceRecognizer` is a :ocv:class:`Algorithm` (see above), you can get/set the thresholds at runtime!

 Here is an example of setting a threshold for the Eigenfaces method, when creating the model:

@@ -71,7 +71,7 @@ You really don't want to create the CSV file by hand. And you really don't want
 Fisherfaces for Gender Classification
 --------------------------------------

-If you want to decide whether a person is *male* or *female*, you have to learn the discriminative features of both classes. The Eigenfaces method is based on the Principal Component Analysis, which is an unsupervised statistical model and not suitable for this task. Please see the Face Recognition tutorial for insights into the algorithms. The Fisherfaces instead yields a class-specific linear projection, so it is much better suited for the gender classification task. `http://www.bytefish.de/blog/gender_classification <http://www.bytefish.de/blog/gender_classification>`_  shows the recognition rate of the Fisherfaces method for gender classification.
+If you want to decide wether a person is *male* or *female*, you have to learn the discriminative features of both classes. The Eigenfaces method is based on the Principal Component Analysis, which is an unsupervised statistical model and not suitable for this task. Please see the Face Recognition tutorial for insights into the algorithms. The Fisherfaces instead yields a class-specific linear projection, so it is much better suited for the gender classification task. `http://www.bytefish.de/blog/gender_classification <http://www.bytefish.de/blog/gender_classification>`_  shows the recognition rate of the Fisherfaces method for gender classification.

 The Fisherfaces method achieves a 98% recognition rate in a subject-independent cross-validation. A subject-independent cross-validation means *images of the person under test are never used for learning the model*. And could you believe it: you can simply use the facerec_fisherfaces demo, that's inlcuded in OpenCV.

@@ -53,7 +53,7 @@ void CvAdaptiveSkinDetector::initData(IplImage *src, int widthDivider, int heigh
    imgGrayFrame = cvCreateImage(imageSize, IPL_DEPTH_8U, 1);
    imgLastGrayFrame = cvCreateImage(imageSize, IPL_DEPTH_8U, 1);
    imgHSVFrame = cvCreateImage(imageSize, IPL_DEPTH_8U, 3);
-}
+};

 CvAdaptiveSkinDetector::CvAdaptiveSkinDetector(int samplingDivider, int morphingMethod)
 {
@@ -78,7 +78,7 @@ CvAdaptiveSkinDetector::CvAdaptiveSkinDetector(int samplingDivider, int morphing
    imgLastGrayFrame = NULL;
    imgSaturationFrame = NULL;
    imgHSVFrame = NULL;
-}
+};

 CvAdaptiveSkinDetector::~CvAdaptiveSkinDetector()
 {
@@ -91,7 +91,7 @@ CvAdaptiveSkinDetector::~CvAdaptiveSkinDetector()
    cvReleaseImage(&imgGrayFrame);
    cvReleaseImage(&imgLastGrayFrame);
    cvReleaseImage(&imgHSVFrame);
-}
+};

 void CvAdaptiveSkinDetector::process(IplImage *inputBGRImage, IplImage *outputHueMask)
 {
@@ -188,7 +188,7 @@ void CvAdaptiveSkinDetector::process(IplImage *inputBGRImage, IplImage *outputHu

    if (outputHueMask != NULL)
        cvCopy(imgFilteredFrame, outputHueMask);
-}
+};


 //------------------------- Histogram for Adaptive Skin Detector -------------------------//
@@ -200,12 +200,12 @@ CvAdaptiveSkinDetector::Histogram::Histogram()
    float *ranges[] = { range };
    fHistogram = cvCreateHist(1, histogramSize, CV_HIST_ARRAY, ranges, 1);
    cvClearHist(fHistogram);
-}
+};

 CvAdaptiveSkinDetector::Histogram::~Histogram()
 {
    cvReleaseHist(&fHistogram);
-}
+};

 int CvAdaptiveSkinDetector::Histogram::findCoverageIndex(double surfaceToCover, int defaultValue)
 {
@@ -219,7 +219,7 @@ int CvAdaptiveSkinDetector::Histogram::findCoverageIndex(double surfaceToCover,
        }
    }
    return defaultValue;
-}
+};

 void CvAdaptiveSkinDetector::Histogram::findCurveThresholds(int &x1, int &x2, double percent)
 {
@@ -242,7 +242,7 @@ void CvAdaptiveSkinDetector::Histogram::findCurveThresholds(int &x1, int &x2, do
        x2 = GSD_HUE_UT;
    else
        x2 += GSD_HUE_LT;
-}
+};

 void CvAdaptiveSkinDetector::Histogram::mergeWith(CvAdaptiveSkinDetector::Histogram *source, double weight)
 {
@@ -283,4 +283,4 @@ void CvAdaptiveSkinDetector::Histogram::mergeWith(CvAdaptiveSkinDetector::Histog
            }
        }
    }
-}
+};
@@ -938,7 +938,7 @@ static void fjac(int /*i*/, int /*j*/, CvMat *point_params, CvMat* cam_params, C

 #endif

-}
+};
 static void func(int /*i*/, int /*j*/, CvMat *point_params, CvMat* cam_params, CvMat* estim, void* /*data*/) {
  //just do projections
  CvMat _Mi;
@@ -977,17 +977,17 @@ static void func(int /*i*/, int /*j*/, CvMat *point_params, CvMat* cam_params, C
  cvTranspose( _mp2, estim );
  cvReleaseMat( &_mp );
  cvReleaseMat( &_mp2 );
-}
+};

 static void fjac_new(int i, int j, Mat& point_params, Mat& cam_params, Mat& A, Mat& B, void* data) {
  CvMat _point_params = point_params, _cam_params = cam_params, _Al = A, _Bl = B;
  fjac(i,j, &_point_params, &_cam_params, &_Al, &_Bl, data);
-}
+};

 static void func_new(int i, int j, Mat& point_params, Mat& cam_params, Mat& estim, void* data)  {
  CvMat _point_params = point_params, _cam_params = cam_params, _estim = estim;
  func(i,j,&_point_params,&_cam_params,&_estim,data);
-}
+};

 void LevMarqSparse::bundleAdjust( vector<Point3d>& points, //positions of points in global coordinate system (input and output)
          const vector<vector<Point2d> >& imagePoints, //projections of 3d points for every camera
@@ -439,8 +439,8 @@ namespace cv
 #ifdef MAKE_PARALLEL
        /******************************************************
        ** IF some parallelizing thread methods are available, then, main loops are parallelized using these functors
-        ** ==> main idea parallelize main filters loops, then, only the most used methods are parallelized... TODO : increase the number of parallelized methods as necessary
-        ** ==> functors names = Parallel_$$$ where $$$= the name of the serial method that is parallelized
+        ** ==> main idea paralellise main filters loops, then, only the most used methods are parallelized... TODO : increase the number of parallelised methods as necessary
+        ** ==> functors names = Parallel_$$$ where $$$= the name of the serial method that is parallelised
        ** ==> functors constructors can differ from the parameters used with their related serial functions
        */

@@ -873,7 +873,7 @@ CV_INIT_ALGORITHM(Eigenfaces, "FaceRecognizer.Eigenfaces",
                  obj.info()->addParam(obj, "labels", obj._labels, true);
                  obj.info()->addParam(obj, "eigenvectors", obj._eigenvectors, true);
                  obj.info()->addParam(obj, "eigenvalues", obj._eigenvalues, true);
-                  obj.info()->addParam(obj, "mean", obj._mean, true))
+                  obj.info()->addParam(obj, "mean", obj._mean, true));

 CV_INIT_ALGORITHM(Fisherfaces, "FaceRecognizer.Fisherfaces",
                  obj.info()->addParam(obj, "ncomponents", obj._num_components);
@@ -882,7 +882,7 @@ CV_INIT_ALGORITHM(Fisherfaces, "FaceRecognizer.Fisherfaces",
                  obj.info()->addParam(obj, "labels", obj._labels, true);
                  obj.info()->addParam(obj, "eigenvectors", obj._eigenvectors, true);
                  obj.info()->addParam(obj, "eigenvalues", obj._eigenvalues, true);
-                  obj.info()->addParam(obj, "mean", obj._mean, true))
+                  obj.info()->addParam(obj, "mean", obj._mean, true));

 CV_INIT_ALGORITHM(LBPH, "FaceRecognizer.LBPH",
                  obj.info()->addParam(obj, "radius", obj._radius);
@@ -891,7 +891,7 @@ CV_INIT_ALGORITHM(LBPH, "FaceRecognizer.LBPH",
                  obj.info()->addParam(obj, "grid_y", obj._grid_y);
                  obj.info()->addParam(obj, "threshold", obj._threshold);
                  obj.info()->addParam(obj, "histograms", obj._histograms, true);
-                  obj.info()->addParam(obj, "labels", obj._labels, true))
+                  obj.info()->addParam(obj, "labels", obj._labels, true));

 bool initModule_contrib()
 {
@@ -40,7 +40,7 @@ CvFuzzyPoint::CvFuzzyPoint(double _x, double _y)
 {
    x = _x;
    y = _y;
-}
+};

 bool CvFuzzyCurve::between(double x, double x1, double x2)
 {
@@ -50,37 +50,37 @@ bool CvFuzzyCurve::between(double x, double x1, double x2)
        return true;

    return false;
-}
+};

 CvFuzzyCurve::CvFuzzyCurve()
 {
    value = 0;
-}
+};

 CvFuzzyCurve::~CvFuzzyCurve()
 {
    // nothing to do
-}
+};

 void CvFuzzyCurve::setCentre(double _centre)
 {
    centre = _centre;
-}
+};

 double CvFuzzyCurve::getCentre()
 {
    return centre;
-}
+};

 void CvFuzzyCurve::clear()
 {
    points.clear();
-}
+};

 void CvFuzzyCurve::addPoint(double x, double y)
 {
    points.push_back(CvFuzzyPoint(x, y));
-}
+};

 double CvFuzzyCurve::calcValue(double param)
 {
@@ -101,41 +101,41 @@ double CvFuzzyCurve::calcValue(double param)
        }
    }
    return 0;
-}
+};

 double CvFuzzyCurve::getValue()
 {
    return value;
-}
+};

 void CvFuzzyCurve::setValue(double _value)
 {
    value = _value;
-}
+};


 CvFuzzyFunction::CvFuzzyFunction()
 {
    // nothing to do
-}
+};

 CvFuzzyFunction::~CvFuzzyFunction()
 {
    curves.clear();
-}
+};

 void CvFuzzyFunction::addCurve(CvFuzzyCurve *curve, double value)
 {
    curves.push_back(*curve);
    curve->setValue(value);
-}
+};

 void CvFuzzyFunction::resetValues()
 {
    int numCurves = (int)curves.size();
    for (int i = 0; i < numCurves; i++)
        curves[i].setValue(0);
-}
+};

 double CvFuzzyFunction::calcValue()
 {
@@ -152,7 +152,7 @@ double CvFuzzyFunction::calcValue()
        return s1/s2;
    else
        return 0;
-}
+};

 CvFuzzyCurve *CvFuzzyFunction::newCurve()
 {
@@ -160,14 +160,14 @@ CvFuzzyCurve *CvFuzzyFunction::newCurve()
    c = new CvFuzzyCurve();
    addCurve(c);
    return c;
-}
+};

 CvFuzzyRule::CvFuzzyRule()
 {
    fuzzyInput1 = NULL;
    fuzzyInput2 = NULL;
    fuzzyOutput = NULL;
-}
+};

 CvFuzzyRule::~CvFuzzyRule()
 {
@@ -179,14 +179,14 @@ CvFuzzyRule::~CvFuzzyRule()

    if (fuzzyOutput != NULL)
        delete fuzzyOutput;
-}
+};

 void CvFuzzyRule::setRule(CvFuzzyCurve *c1, CvFuzzyCurve *c2, CvFuzzyCurve *o1)
 {
    fuzzyInput1 = c1;
    fuzzyInput2 = c2;
    fuzzyOutput = o1;
-}
+};

 double CvFuzzyRule::calcValue(double param1, double param2)
 {
@@ -202,31 +202,31 @@ double CvFuzzyRule::calcValue(double param1, double param2)
    }
    else
        return v1;
-}
+};

 CvFuzzyCurve *CvFuzzyRule::getOutputCurve()
 {
    return fuzzyOutput;
-}
+};

 CvFuzzyController::CvFuzzyController()
 {
    // nothing to do
-}
+};

 CvFuzzyController::~CvFuzzyController()
 {
    int size = (int)rules.size();
    for(int i = 0; i < size; i++)
        delete rules[i];
-}
+};

 void CvFuzzyController::addRule(CvFuzzyCurve *c1, CvFuzzyCurve *c2, CvFuzzyCurve *o1)
 {
    CvFuzzyRule *f = new CvFuzzyRule();
    rules.push_back(f);
    f->setRule(c1, c2, o1);
-}
+};

 double CvFuzzyController::calcOutput(double param1, double param2)
 {
@@ -242,7 +242,7 @@ double CvFuzzyController::calcOutput(double param1, double param2)
    }
    v = list.calcValue();
    return v;
-}
+};

 CvFuzzyMeanShiftTracker::FuzzyResizer::FuzzyResizer()
 {
@@ -298,12 +298,12 @@ CvFuzzyMeanShiftTracker::FuzzyResizer::FuzzyResizer()
    fuzzyController.addRule(i1L, NULL, oS);
    fuzzyController.addRule(i1M, NULL, oZE);
    fuzzyController.addRule(i1H, NULL, oE);
-}
+};

 int CvFuzzyMeanShiftTracker::FuzzyResizer::calcOutput(double edgeDensity, double density)
 {
    return (int)fuzzyController.calcOutput(edgeDensity, density);
-}
+};

 CvFuzzyMeanShiftTracker::SearchWindow::SearchWindow()
 {
@@ -328,7 +328,7 @@ CvFuzzyMeanShiftTracker::SearchWindow::SearchWindow()
    depthLow = 0;
    depthHigh = 0;
    fuzzyResizer = NULL;
-}
+};

 CvFuzzyMeanShiftTracker::SearchWindow::~SearchWindow()
 {
@@ -354,7 +354,7 @@ void CvFuzzyMeanShiftTracker::SearchWindow::setSize(int _x, int _y, int _width,

    if (y + height > maxHeight)
        height = maxHeight - y;
-}
+};

 void CvFuzzyMeanShiftTracker::SearchWindow::initDepthValues(IplImage *maskImage, IplImage *depthMap)
 {
@@ -408,7 +408,7 @@ void CvFuzzyMeanShiftTracker::SearchWindow::initDepthValues(IplImage *maskImage,
        depthHigh = 32000;
        depthLow = 0;
    }
-}
+};

 bool CvFuzzyMeanShiftTracker::SearchWindow::shift()
 {
@@ -421,7 +421,7 @@ bool CvFuzzyMeanShiftTracker::SearchWindow::shift()
    {
        return false;
    }
-}
+};

 void CvFuzzyMeanShiftTracker::SearchWindow::extractInfo(IplImage *maskImage, IplImage *depthMap, bool initDepth)
 {
@@ -527,7 +527,7 @@ void CvFuzzyMeanShiftTracker::SearchWindow::extractInfo(IplImage *maskImage, Ipl
        ellipseAngle = 0;
        density = 0;
    }
-}
+};

 void CvFuzzyMeanShiftTracker::SearchWindow::getResizeAttribsEdgeDensityLinear(int &resizeDx, int &resizeDy, int &resizeDw, int &resizeDh) {
    int x1 = horizontalEdgeTop;
@@ -571,7 +571,7 @@ void CvFuzzyMeanShiftTracker::SearchWindow::getResizeAttribsEdgeDensityLinear(in
    } else {
        resizeDw = - resizeDx;
    }
-}
+};

 void CvFuzzyMeanShiftTracker::SearchWindow::getResizeAttribsInnerDensity(int &resizeDx, int &resizeDy, int &resizeDw, int &resizeDh)
 {
@@ -587,7 +587,7 @@ void CvFuzzyMeanShiftTracker::SearchWindow::getResizeAttribsInnerDensity(int &re
    resizeDy = (int)(py*dy);
    resizeDw = (int)((1-px)*dx);
    resizeDh = (int)((1-py)*dy);
-}
+};

 void CvFuzzyMeanShiftTracker::SearchWindow::getResizeAttribsEdgeDensityFuzzy(int &resizeDx, int &resizeDy, int &resizeDw, int &resizeDh)
 {
@@ -626,7 +626,7 @@ void CvFuzzyMeanShiftTracker::SearchWindow::getResizeAttribsEdgeDensityFuzzy(int
        resizeDy = int(-dy1);
        resizeDh = int(dy1+dy2);
    }
-}
+};

 bool CvFuzzyMeanShiftTracker::SearchWindow::meanShift(IplImage *maskImage, IplImage *depthMap, int maxIteration, bool initDepth)
 {
@@ -639,7 +639,7 @@ bool CvFuzzyMeanShiftTracker::SearchWindow::meanShift(IplImage *maskImage, IplIm
    } while (++numShifts < maxIteration);

    return false;
-}
+};

 void CvFuzzyMeanShiftTracker::findOptimumSearchWindow(SearchWindow &searchWindow, IplImage *maskImage, IplImage *depthMap, int maxIteration, int resizeMethod, bool initDepth)
 {
@@ -679,17 +679,17 @@ void CvFuzzyMeanShiftTracker::findOptimumSearchWindow(SearchWindow &searchWindow

        searchWindow.setSize(searchWindow.x + resizeDx, searchWindow.y + resizeDy, searchWindow.width + resizeDw, searchWindow.height + resizeDh);
    }
-}
+};

 CvFuzzyMeanShiftTracker::CvFuzzyMeanShiftTracker()
 {
    searchMode = tsSetWindow;
-}
+};

 CvFuzzyMeanShiftTracker::~CvFuzzyMeanShiftTracker()
 {
    // nothing to do
-}
+};

 void CvFuzzyMeanShiftTracker::track(IplImage *maskImage, IplImage *depthMap, int resizeMethod, bool resetSearch, int minKernelMass)
 {
@@ -717,4 +717,4 @@ void CvFuzzyMeanShiftTracker::track(IplImage *maskImage, IplImage *depthMap, int
            else
                searchMode = tsTracking;
    }
-}
+};
@@ -362,14 +362,14 @@ bool ImageLogPolProjection::_initLogPolarCortexSampling(const double reductionFa

    //std::cout<<"ImageLogPolProjection::Starting cortex projection"<<std::endl;
    // compute transformation, get theta and Radius in reagrd of the output sampled pixel
-    double diagonalLength=sqrt((double)(_outputNBcolumns*_outputNBcolumns+_outputNBrows*_outputNBrows));
+    double diagonalLenght=sqrt((double)(_outputNBcolumns*_outputNBcolumns+_outputNBrows*_outputNBrows));
    for (unsigned int radiusIndex=0;radiusIndex<_outputNBcolumns;++radiusIndex)
        for(unsigned int orientationIndex=0;orientationIndex<_outputNBrows;++orientationIndex)
        {
            double x=1.0+sinh(radiusAxis[radiusIndex])*cos(orientationAxis[orientationIndex]);
            double y=sinh(radiusAxis[radiusIndex])*sin(orientationAxis[orientationIndex]);
            // get the input picture coordinate
-            double R=diagonalLength*sqrt(x*x+y*y)/(5.0+sqrt(x*x+y*y));
+            double R=diagonalLenght*sqrt(x*x+y*y)/(5.0+sqrt(x*x+y*y));
            double theta=atan2(y,x);
            // convert input polar coord into cartesian/C compatble coordinate
            unsigned int columnIndex=(unsigned int)(cos(theta)*R)+halfInputColumns;
@@ -229,7 +229,7 @@ Mat subspaceReconstruct(InputArray _W, InputArray _mean, InputArray _src)
        string error_message = format("Wrong mean shape for the given eigenvector matrix. Expected %d, but was %d.", W.cols, mean.total());
        CV_Error(CV_StsBadArg, error_message);
    }
-    // initialize temporary matrices
+    // initalize temporary matrices
    Mat X, Y;
    // copy data & make sure we are using the correct type
    src.convertTo(Y, W.type());
@@ -195,8 +195,8 @@ namespace cv
 #ifdef MAKE_PARALLEL
        /******************************************************
        ** IF some parallelizing thread methods are available, then, main loops are parallelized using these functors
-        ** ==> main idea parallelize main filters loops, then, only the most used methods are parallelized... TODO : increase the number of parallelized methods as necessary
-        ** ==> functors names = Parallel_$$$ where $$$= the name of the serial method that is parallelized
+        ** ==> main idea paralellise main filters loops, then, only the most used methods are parallelized... TODO : increase the number of parallelised methods as necessary
+        ** ==> functors names = Parallel_$$$ where $$$= the name of the serial method that is parallelised
        ** ==> functors constructors can differ from the parameters used with their related serial functions
        */
        class Parallel_amacrineCellsComputing: public cv::ParallelLoopBody
@@ -219,8 +219,8 @@ private:
 #ifdef MAKE_PARALLEL
 /******************************************************
 ** IF some parallelizing thread methods are available, then, main loops are parallelized using these functors
-** ==> main idea parallelize main filters loops, then, only the most used methods are parallelized... TODO : increase the number of parallelized methods as necessary
-** ==> functors names = Parallel_$$$ where $$$= the name of the serial method that is parallelized
+** ==> main idea paralellise main filters loops, then, only the most used methods are parallelized... TODO : increase the number of parallelised methods as necessary
+** ==> functors names = Parallel_$$$ where $$$= the name of the serial method that is parallelised
 ** ==> functors constructors can differ from the parameters used with their related serial functions
 */
    class Parallel_OPL_OnOffWaysComputing: public cv::ParallelLoopBody
@@ -85,7 +85,7 @@ Retina::Retina(const cv::Size inputSz, const bool colorMode, RETINA_COLORSAMPLIN
 {
    _retinaFilter = 0;
    _init(inputSz, colorMode, colorSamplingMethod, useRetinaLogSampling, reductionFactor, samplingStrenght);
-}
+};

 Retina::~Retina()
 {
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Vladislav Vinogradov	b4845d8c9f	temporary disable performance test for alphaComp function(cherry picked from commit `1ce5165cb7`)	2014-02-14 17:12:31 +04:00
Alexander Smorkalov	ea51396731	Dead code removed as this cannot be null in Java. (cherry picked from commit `dbe7634286`)	2014-02-13 20:13:47 +04:00
Vladislav Vinogradov	aa82f921cc	temporary disable perf test for StereoBeliefPropagation(cherry picked from commit `eb247d826f`)	2014-02-13 20:13:38 +04:00
Vladislav Vinogradov	2da7eae2c4	increase epsilon for AlphaComp sanity test for integer input(cherry picked from commit `9e69e2a07a`)	2014-02-13 20:13:27 +04:00
Alexander Smorkalov	25159d8e81	Application pause/resume fix for Android sample NativeActivity. (cherry picked from commit `7da3e98dfd`)	2014-02-13 17:59:23 +04:00
Alexander Smorkalov	f40ffe4763	LICENSE and README files installation rules added. (cherry picked from commit `e55f2b2602`)	2014-02-12 19:36:52 +04:00
Alexander Smorkalov	116311b7b4	opencv_run_all_tests.sh implemented for Android SDK. (cherry picked from commit `d02c291160`)	2014-02-12 19:36:43 +04:00
Alexander Smorkalov	f1ef3a4865	OpenCV version++.	2014-02-11 10:15:02 +04:00
Vladislav Vinogradov	9997aa8187	decrease input size for several gpu tests to fix "timed out" error: * BruteForceNonLocalMeans * OpticalFlowBM(cherry picked from commit `8b44a42a40`)	2014-02-10 15:48:52 +04:00
Vladislav Vinogradov	f15b42018c	fix nonfree module compilation without CUDA(cherry picked from commit `3e1f74f2ca`)	2014-02-10 15:48:52 +04:00
Alexander Smorkalov	f9e9ae85bd	dynamicuda module disabled in OpenCv.mk for all arches except armeabi-v7a. (cherry picked from commit `b10d4b05ed`)	2014-02-10 15:48:52 +04:00
Alexander Smorkalov	a49beb7c73	Multiple improvements in OpenCV examples build. EMBED_CUDA and FORCE_EMBED_OPENCV flags added to cmake macro add_android_project; INSTALL_CUDA_LIBRARIES option added to OpenCV.mk opencv_dynamicuda library installation with enabled OPENCV_INSTALL_MODULES flag fixed; CUDA initialization apportunity added to OpenCVLoader.initDebug(); Tutorial-4-CUDA sample reimplemented with static OpenCV and CUDA initialization. (cherry picked from commit `6ae4a9b09b`)	2014-02-10 15:48:52 +04:00
Alexander Smorkalov	51dff5b9e8	project.properties file generation fixed for per-component installation. (cherry picked from commit `65b4d77959`)	2014-02-10 15:48:52 +04:00
Alexander Smorkalov	826fc00374	Tests install path fix for Android SDK. (cherry picked from commit `0cd0e4749b`)	2014-02-10 15:48:52 +04:00
Vladislav Vinogradov	c10692deff	save previous values of LOCAL_* variables and restore them at the end(cherry picked from commit `286fe261d0`)	2014-02-10 15:48:52 +04:00
Vladislav Vinogradov	daa7b9ce5f	fix path to CUDA libraries (use targets/armv7-linux-androideabi/lib)(cherry picked from commit `a098fb1803`)	2014-02-10 15:48:52 +04:00
Vladislav Vinogradov	1ab02631b0	update stitching sample (cherry picked from commit `214cbabc40`)	2014-02-10 15:48:52 +04:00
Vladislav Vinogradov	3e755b2290	turn on CUDA part of stitching module on Android for non-dynamic build(cherry picked from commit `a138e5a6a5`)	2014-02-10 15:48:51 +04:00
Vladislav Vinogradov	f15a167df4	turn on CUDA part of nonfree module on Android for non-dynamic build(cherry picked from commit `d8f7377122`)	2014-02-10 15:48:51 +04:00
Ilya Lavrenov	f6367a2ea5	eliminated possible memory leak (cherry picked from commit `e7e63fac6c`)	2014-02-10 15:48:51 +04:00
Vladislav Vinogradov	5f88e2b496	fix #3477 : CV_CAP_PROP_SUPPORTED_PREVIEW_SIZES_STRING property is not supported by all VideoCapture backends. Some backends can return 0.0 or -1.0.(cherry picked from commit `c41e8006c7`)	2014-02-10 15:48:51 +04:00
Seunghoon Park	2c7cf52e3b	fixing bug #3345 . use norm to make sure two matrices are the same. (cherry picked from commit `eb9d7c4dd5`)	2014-02-10 15:48:51 +04:00
Andrey Pavlenko	b7c5083a87	removing duplicated legacy license, the actual instance is in 'opencv/LICENSE' (cherry picked from commit `dca5684145`)	2014-02-10 15:48:51 +04:00
Vladislav Vinogradov	d5d88efd5d	fix GpuMat::copyTo method with mask: fill destination matrix with zeros if it was reallocated(cherry picked from commit `dda999545c`)	2014-02-10 15:48:51 +04:00
Drew Jetter	6cb7a7be18	Fixed bug #3489 : The code assumed that two global variables would be constructed in a particular order, but global variable initialization order is compiler-dependent. (cherry picked from commit `6bf599b1bc`)	2014-02-10 15:48:51 +04:00
Pierre-Emmanuel Viel	cdea6b532f	Fix: freeing previous elements has to be done before loading new parameters to avoid trying to delete unexisting objects if arrays size was modified (cherry picked from commit `3f458c6eb1`)	2014-02-10 15:48:51 +04:00
ComFreek	d01e3529a6	Corrected package name in tutorial See also #2101(cherry picked from commit `ae795e5797`)	2014-02-10 15:48:51 +04:00
Nghia Ho	7c13d3277c	Fixed a valgrind 'Conditional jump or move depends on uninitialised value(s)' on cv::kmeans(...). The original code used points(sampleCount, 1, CV_32FC2), which confused generateCentersPP into thinking it is a 1 dimensional center, instead of 2. As a result it would set only the x variable and leave y unitialised. (cherry picked from commit `601b7d1dd3`)	2014-02-10 15:48:51 +04:00
Robbert Klarenbeek	345b3b0bdd	Fix algorithm setter argument validation for uchar(cherry picked from commit `e21c6e19db`)	2014-02-10 15:48:51 +04:00
Kazuki Matsuda	a65d7d4dd3	Fix typo of SparseMat_<_Tp>::SparseMat_(const SparseMat& m) Fix compilation erros when compiling this constructor. First argument type of "convertTo" should be instance, not a pointer of instance. First pull request was created for master branch. But it should be marged for 2.4. https://github.com/Itseez/opencv/pull/2113 (cherry picked from commit `2ae20c74a2`)	2014-02-10 15:48:51 +04:00
Ilya Lavrenov	5e986f3347	fixed bug #3319 (cherry picked from commit `4f9c081dc3`)	2014-02-10 15:48:50 +04:00
Seunghoon Park	27a8bb471b	fixing bug #3345 . don't use BORDER_ISOLATED alone. it should be combined with some border type (cherry picked from commit `2272a58769`)	2014-02-10 15:48:50 +04:00
Seunghoon Park	7868733002	fixing bug #3345 (cherry picked from commit `b036fc756a`)	2014-02-10 15:48:50 +04:00
Ilya Lavrenov	469aef2e5e	fixed bug #3341 (cherry picked from commit `09d25e11c6`)	2014-02-10 15:48:50 +04:00
Roman Donchenko	5e00fc6afe	Fixed MinGW build by declaring the minimal required Windows version. Also deleted miscellaneous remaining multimon cruft. Deleted #include <winuser.h>, because <windows.h> includes it already. This should have a nice side effect of preventing us from accidentally using any Windows API that's too new. (cherry picked from commit `795c108f2b`)	2014-02-10 15:48:50 +04:00
Vladislav Vinogradov	5170f0b5da	fixed several bugs in CUDA Canny implementation: * out of border access in edgesHysteresisLocalKernel * incorrect usage of atomicAdd(cherry picked from commit `5dbdadb769`)	2014-02-07 20:59:13 +04:00
Vladislav Vinogradov	dc2dbb4173	Revert "disable gpu Canny and HoughCircles perf tests:" This reverts commit `dbce90692a`. (cherry picked from commit `bfc27271e2`)	2014-02-07 20:58:49 +04:00
Vladislav Vinogradov	79e4f7eb78	Revert "disable CUDA generalized Hough Transform" This reverts commit `33d42b740c`. (cherry picked from commit `5d099df578`)	2014-02-07 18:24:57 +04:00
Vladislav Vinogradov	cc73c7000f	fix epsilons for several gpu tests (cherry picked from commit `3e4bb371c8`)	2014-02-07 18:24:44 +04:00
Vladislav Vinogradov	8bb26fa5de	Revert "disable gpu CvtColor.*2HSV tests:" This reverts commit `952027a853`. (cherry picked from commit `b6ba1f226c`)	2014-02-07 18:24:35 +04:00
Vladislav Vinogradov	48612d7c58	Revert "disable gpu Subtract_Array test:" This reverts commit `e91bf95d58`. (cherry picked from commit `da44a2fac1`)	2014-02-07 18:24:23 +04:00
Alexander Smorkalov	8ba84f4b47	Implicit testdata directory permissions setup added. (cherry picked from commit `b86088b89c`)	2014-02-07 18:24:11 +04:00
Alexander Smorkalov	bc653add74	Absolute path to tests in opencv_run_app_tests.sh fixed. (cherry picked from commit `530702c5f2`)	2014-02-06 17:16:21 +04:00
Alexander Smorkalov	215f78eee2	Merge branch 'android_manager_version_inc4' into 2.4.8.1-prep	2014-01-31 22:25:36 +04:00
Vladislav Vinogradov	4425dac7f4	disable gpu CvtColor.*2HSV tests: possible bug in CPU version(cherry picked from commit 3cb8b352e52f85847d98d2b0ece32ba5bdb5c31b)	2014-01-31 22:24:20 +04:00
Vladislav Vinogradov	4f79b9de48	disable gpu Subtract_Array test: possible bug in CPU version(cherry picked from commit 59155c1eefb6f22e362e34a8d73b31841eb3413a)	2014-01-31 22:23:55 +04:00
Vladislav Vinogradov	397ac5e68f	disable gpu Canny and HoughCircles perf tests: it fails because driver terminates CUDA kernels after time out (cherry picked from commit fa5bbb5f8dc1a86cfe004fb258d66e56c90560d6)	2014-01-31 22:23:39 +04:00
Vladislav Vinogradov	43c75c64b5	disable NPP for GpuMat methods and for copyMakeBorder(cherry picked from commit 316d49fc0fb7a609ebb0a65efc207faea6b978a4)	2014-01-31 22:23:22 +04:00
Vladislav Vinogradov	c319625a07	disable some gpu tests if library was built without CUFFT(cherry picked from commit b4b929d27cc25822dd15b5b96b8d335c59d4408c)	2014-01-31 22:23:05 +04:00
Vladislav Vinogradov	a7d0448faa	gpu test output files moved from cwd to temp folder(cherry picked from commit `49731ad530`)	2014-01-31 22:22:49 +04:00
Alexander Smorkalov	ca10e5e8ae	Highgui test output fixes. Useless output to console fixed; Test output files moved from cwd to temp folder. (cherry picked from commit `87935f3560`)	2014-01-31 22:22:33 +04:00
Vladislav Vinogradov	32414afe72	disable performance test for gpu generalized hough(cherry picked from commit `063d8b4211`)	2014-01-31 22:22:14 +04:00
Alexander Smorkalov	ed10f50d25	Reports path fix for opencv_run_all_tests.sh.in script. (cherry picked from commit `3d261e8a01`)	2014-01-31 22:21:57 +04:00
Alexander Smorkalov	48d9be70d5	Android toolchain file sync with original project. Original project: https://github.com/taka-no-me/android-cmake/ Revision: 5db45cfb87fec180b74963d3680dd60d4d8d8c3a (cherry picked from commit `c815043607`)	2014-01-31 22:21:34 +04:00
Alexander Smorkalov	c6b31481b6	OpenCV Manager version++.	2014-01-31 12:15:22 +04:00
Alexander Smorkalov	514b714cc2	opencv_run_all_tests.sh script added to -tests package. (cherry picked from commit `d45350a06a`)	2014-01-29 17:41:59 +04:00
Alexander Smorkalov	7fec87d3f6	Multiple fixes for tests deb package build. Added opencv_testing.sh.in file; opencv_testing.sh installation guarded by OS check. (cherry picked from commit `d9dc5ffa91`)	2014-01-28 17:56:22 +04:00
Alexander Smorkalov	00d555f051	Code review notes fixed. Env setup for testing package implemented using /etc/profile.d; Variable with path for all native samples added; Path for test binaries and test data updated. (cherry picked from commit `39201e68e2`)	2014-01-27 21:37:01 +04:00
Alexander Smorkalov	6cf7d6ef4e	OpenCV C/C++/OCL/CUDA samples install path fixed. Install rools for tests added. (cherry picked from commit `f332cba14b`)	2014-01-27 21:36:43 +04:00
Alexander Smorkalov	3ebdcafdd3	All installed files marked with component names for install customization. (cherry picked from commit `b75cbfde45`) Conflicts: cmake/OpenCVModule.cmake	2014-01-24 17:13:22 +04:00
Alexander Smorkalov	a348f3eeaa	OpenCV version++	2014-01-24 14:49:56 +04:00
Alexander Smorkalov	33f423de04	Improvements in package build. (cherry picked from commit `086792ec06`)	2014-01-24 14:48:51 +04:00
Alexander Smorkalov	d6ba52c3f9	Initial Linux packages build rools for CPack. (cherry picked from commit `7821fe2bde`) Conflicts: cmake/OpenCVModule.cmake	2014-01-24 14:48:19 +04:00
Vladislav Vinogradov	e9638d0997	disable CUDA generalized Hough Transform (cherry picked from commit `33d42b740c`)	2014-01-24 14:46:36 +04:00
Vladislav Vinogradov	5cb0084547	split CUDA Hough sources (cherry picked from commit `d847387694`)	2014-01-24 14:46:16 +04:00