Chiebot-Mirror
/
opencv
8
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Merge remote-tracking branch 'origin/master'

Browse Source
pull/32/head
Vadim Pisarevsky 13 years ago
parent 7946fcdb69 e73089bdb5
commit 37f4ea6be7
19 changed files with 669 additions and 527 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 107
      CMakeLists.txt
  2. 95
      cmake/OpenCVCompilerOptions.cmake
  3. 4
      cmake/OpenCVDetectCXXCompiler.cmake
  4. 4
      cmake/OpenCVFindLibsPerf.cmake
  5. 2
      cmake/OpenCVFindLibsVideo.cmake
  6. 67
      modules/core/include/opencv2/core/internal.hpp
  7. 2
      modules/core/test/test_operations.cpp
  8. 2
      modules/gpu/perf/perf_imgproc.cpp
  9. 10
      modules/imgproc/test/test_imgwarp_strict.cpp
  10. 45
      modules/java/CMakeLists.txt
  11. 20
      modules/java/generator/gen_java.py
  12. 25
      modules/java/generator/src/cpp/Mat.cpp
  13. 10
      modules/java/generator/src/cpp/converters.cpp
  14. 2
      modules/java/generator/src/cpp/features2d_manual.hpp
  15. 4
      modules/java/generator/src/cpp/utils.cpp
  16. 15
      modules/java/jar/build.xml
  17. 776
      modules/objdetect/src/haar.cpp
  18. 2
      samples/cpp/pca.cpp
  19. 4
      samples/cpp/simpleflow_demo.cpp

107
CMakeLists.txt
Unescape View File

@ -60,7 +60,7 @@ endif()
project(OpenCV CXX C) project(OpenCV CXX C)
include(cmake/OpenCVUtils.cmake REQUIRED) include(cmake/OpenCVUtils.cmake)
# ---------------------------------------------------------------------------- # ----------------------------------------------------------------------------
# Break in case of popular CMake configuration mistakes # Break in case of popular CMake configuration mistakes
@ -73,7 +73,7 @@ endif()
# ---------------------------------------------------------------------------- # ----------------------------------------------------------------------------
# Detect compiler and target platform architecture # Detect compiler and target platform architecture
# ---------------------------------------------------------------------------- # ----------------------------------------------------------------------------
include(cmake/OpenCVDetectCXXCompiler.cmake REQUIRED) include(cmake/OpenCVDetectCXXCompiler.cmake)
# Add these standard paths to the search paths for FIND_LIBRARY # Add these standard paths to the search paths for FIND_LIBRARY
# to find libraries from these locations first # to find libraries from these locations first
@ -159,7 +159,6 @@ OCV_OPTION(BUILD_FAT_JAVA_LIB "Create fat java wrapper containing the whol
OCV_OPTION(BUILD_ANDROID_SERVICE "Build OpenCV Manager for Google Play" OFF IF ANDROID AND ANDROID_USE_STLPORT AND ANDROID_SOURCE_TREE ) OCV_OPTION(BUILD_ANDROID_SERVICE "Build OpenCV Manager for Google Play" OFF IF ANDROID AND ANDROID_USE_STLPORT AND ANDROID_SOURCE_TREE )
OCV_OPTION(BUILD_ANDROID_PACKAGE "Build platform-specific package for Google Play" OFF IF ANDROID ) OCV_OPTION(BUILD_ANDROID_PACKAGE "Build platform-specific package for Google Play" OFF IF ANDROID )
# 3rd party libs # 3rd party libs
OCV_OPTION(BUILD_ZLIB "Build zlib from source" WIN32 OR APPLE ) OCV_OPTION(BUILD_ZLIB "Build zlib from source" WIN32 OR APPLE )
OCV_OPTION(BUILD_TIFF "Build libtiff from source" WIN32 OR ANDROID OR APPLE ) OCV_OPTION(BUILD_TIFF "Build libtiff from source" WIN32 OR ANDROID OR APPLE )
@ -168,24 +167,19 @@ OCV_OPTION(BUILD_JPEG "Build libjpeg from source" WIN32 OR AN
OCV_OPTION(BUILD_PNG "Build libpng from source" WIN32 OR ANDROID OR APPLE ) OCV_OPTION(BUILD_PNG "Build libpng from source" WIN32 OR ANDROID OR APPLE )
OCV_OPTION(BUILD_OPENEXR "Build openexr from source" WIN32 OR ANDROID OR APPLE ) OCV_OPTION(BUILD_OPENEXR "Build openexr from source" WIN32 OR ANDROID OR APPLE )
# OpenCV installation options # OpenCV installation options
# =================================================== # ===================================================
OCV_OPTION(INSTALL_C_EXAMPLES "Install C examples" OFF ) OCV_OPTION(INSTALL_C_EXAMPLES "Install C examples" OFF )
OCV_OPTION(INSTALL_PYTHON_EXAMPLES "Install Python examples" OFF ) OCV_OPTION(INSTALL_PYTHON_EXAMPLES "Install Python examples" OFF )
OCV_OPTION(INSTALL_ANDROID_EXAMPLES "Install Android examples" OFF IF ANDROID ) OCV_OPTION(INSTALL_ANDROID_EXAMPLES "Install Android examples" OFF IF ANDROID )
OCV_OPTION(INSTALL_TO_MANGLED_PATHS "Enables mangled install paths, that help with side by side installs." OFF IF (UNIX AND NOT ANDROID AND NOT IOS AND BUILD_SHARED_LIBS) ) OCV_OPTION(INSTALL_TO_MANGLED_PATHS "Enables mangled install paths, that help with side by side installs." OFF IF (UNIX AND NOT ANDROID AND NOT IOS AND BUILD_SHARED_LIBS) )
if(MSVC_IDE OR CMAKE_GENERATOR MATCHES Xcode)
set(ENABLE_SOLUTION_FOLDERS0 ON)
else()
set(ENABLE_SOLUTION_FOLDERS0 OFF)
endif()
# OpenCV build options # OpenCV build options
# =================================================== # ===================================================
OCV_OPTION(ENABLE_PRECOMPILED_HEADERS "Use precompiled headers" ON IF (NOT IOS) ) 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" ${ENABLE_SOLUTION_FOLDERS0} IF (CMAKE_VERSION VERSION_GREATER "2.8.0") ) 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_PROFILING "Enable profiling in the GCC compiler (Add flags: -g -pg)" OFF IF CMAKE_COMPILER_IS_GNUCXX )
OCV_OPTION(ENABLE_OMIT_FRAME_POINTER "Enable -fomit-frame-pointer for GCC" ON IF CMAKE_COMPILER_IS_GNUCXX ) OCV_OPTION(ENABLE_OMIT_FRAME_POINTER "Enable -fomit-frame-pointer for GCC" ON IF CMAKE_COMPILER_IS_GNUCXX )
OCV_OPTION(ENABLE_POWERPC "Enable PowerPC for GCC" ON IF (CMAKE_COMPILER_IS_GNUCXX AND CMAKE_SYSTEM_PROCESSOR MATCHES powerpc.*) ) OCV_OPTION(ENABLE_POWERPC "Enable PowerPC for GCC" ON IF (CMAKE_COMPILER_IS_GNUCXX AND CMAKE_SYSTEM_PROCESSOR MATCHES powerpc.*) )
@ -196,6 +190,7 @@ OCV_OPTION(ENABLE_SSE3 "Enable SSE3 instructions"
OCV_OPTION(ENABLE_SSSE3 "Enable SSSE3 instructions" OFF IF (CMAKE_COMPILER_IS_GNUCXX AND (X86 OR X86_64)) ) OCV_OPTION(ENABLE_SSSE3 "Enable SSSE3 instructions" OFF IF (CMAKE_COMPILER_IS_GNUCXX AND (X86 OR X86_64)) )
OCV_OPTION(ENABLE_SSE41 "Enable SSE4.1 instructions" OFF IF ((CV_ICC OR CMAKE_COMPILER_IS_GNUCXX) AND (X86 OR X86_64)) ) OCV_OPTION(ENABLE_SSE41 "Enable SSE4.1 instructions" OFF IF ((CV_ICC OR CMAKE_COMPILER_IS_GNUCXX) AND (X86 OR X86_64)) )
OCV_OPTION(ENABLE_SSE42 "Enable SSE4.2 instructions" OFF IF (CMAKE_COMPILER_IS_GNUCXX AND (X86 OR X86_64)) ) OCV_OPTION(ENABLE_SSE42 "Enable SSE4.2 instructions" OFF IF (CMAKE_COMPILER_IS_GNUCXX AND (X86 OR X86_64)) )
OCV_OPTION(ENABLE_AVX "Enable AVX instructions" OFF IF ((MSVC OR CMAKE_COMPILER_IS_GNUCXX) AND (X86 OR X86_64)) )
OCV_OPTION(ENABLE_NOISY_WARNINGS "Show all warnings even if they are too noisy" OFF ) OCV_OPTION(ENABLE_NOISY_WARNINGS "Show all warnings even if they are too noisy" OFF )
OCV_OPTION(OPENCV_WARNINGS_ARE_ERRORS "Treat warnings as errors" OFF ) OCV_OPTION(OPENCV_WARNINGS_ARE_ERRORS "Treat warnings as errors" OFF )
@ -212,7 +207,7 @@ include(cmake/OpenCVLegacyOptions.cmake OPTIONAL)
# ---------------------------------------------------------------------------- # ----------------------------------------------------------------------------
# Get actual OpenCV version number from sources # Get actual OpenCV version number from sources
# ---------------------------------------------------------------------------- # ----------------------------------------------------------------------------
include(cmake/OpenCVVersion.cmake REQUIRED) include(cmake/OpenCVVersion.cmake)
# ---------------------------------------------------------------------------- # ----------------------------------------------------------------------------
@ -223,33 +218,33 @@ include(cmake/OpenCVVersion.cmake REQUIRED)
set(EXECUTABLE_OUTPUT_PATH "${CMAKE_BINARY_DIR}/bin" CACHE PATH "Output directory for applications" ) set(EXECUTABLE_OUTPUT_PATH "${CMAKE_BINARY_DIR}/bin" CACHE PATH "Output directory for applications" )
if(ANDROID OR WIN32) if(ANDROID OR WIN32)
set(OPENCV_DOC_INSTALL_PATH doc) set(OPENCV_DOC_INSTALL_PATH doc)
elseif(INSTALL_TO_MANGLED_PATHS) elseif(INSTALL_TO_MANGLED_PATHS)
set(OPENCV_DOC_INSTALL_PATH share/OpenCV-${OPENCV_VERSION}/doc) set(OPENCV_DOC_INSTALL_PATH share/OpenCV-${OPENCV_VERSION}/doc)
else() else()
set(OPENCV_DOC_INSTALL_PATH share/OpenCV/doc) set(OPENCV_DOC_INSTALL_PATH share/OpenCV/doc)
endif() endif()
if(ANDROID) if(ANDROID)
set(LIBRARY_OUTPUT_PATH "${OpenCV_BINARY_DIR}/lib/${ANDROID_NDK_ABI_NAME}") set(LIBRARY_OUTPUT_PATH "${OpenCV_BINARY_DIR}/lib/${ANDROID_NDK_ABI_NAME}")
set(3P_LIBRARY_OUTPUT_PATH "${OpenCV_BINARY_DIR}/3rdparty/lib/${ANDROID_NDK_ABI_NAME}") set(3P_LIBRARY_OUTPUT_PATH "${OpenCV_BINARY_DIR}/3rdparty/lib/${ANDROID_NDK_ABI_NAME}")
set(OPENCV_LIB_INSTALL_PATH sdk/native/libs/${ANDROID_NDK_ABI_NAME}) set(OPENCV_LIB_INSTALL_PATH sdk/native/libs/${ANDROID_NDK_ABI_NAME})
set(OPENCV_3P_LIB_INSTALL_PATH sdk/native/3rdparty/libs/${ANDROID_NDK_ABI_NAME}) set(OPENCV_3P_LIB_INSTALL_PATH sdk/native/3rdparty/libs/${ANDROID_NDK_ABI_NAME})
set(OPENCV_CONFIG_INSTALL_PATH sdk/native/jni) set(OPENCV_CONFIG_INSTALL_PATH sdk/native/jni)
set(OPENCV_INCLUDE_INSTALL_PATH sdk/native/jni/include) set(OPENCV_INCLUDE_INSTALL_PATH sdk/native/jni/include)
else() else()
set(LIBRARY_OUTPUT_PATH "${OpenCV_BINARY_DIR}/lib") set(LIBRARY_OUTPUT_PATH "${OpenCV_BINARY_DIR}/lib")
set(3P_LIBRARY_OUTPUT_PATH "${OpenCV_BINARY_DIR}/3rdparty/lib${LIB_SUFFIX}") set(3P_LIBRARY_OUTPUT_PATH "${OpenCV_BINARY_DIR}/3rdparty/lib${LIB_SUFFIX}")
set(OPENCV_LIB_INSTALL_PATH lib${LIB_SUFFIX}) set(OPENCV_LIB_INSTALL_PATH lib${LIB_SUFFIX})
set(OPENCV_3P_LIB_INSTALL_PATH share/OpenCV/3rdparty/${OPENCV_LIB_INSTALL_PATH}) set(OPENCV_3P_LIB_INSTALL_PATH share/OpenCV/3rdparty/${OPENCV_LIB_INSTALL_PATH})
set(OPENCV_INCLUDE_INSTALL_PATH include) set(OPENCV_INCLUDE_INSTALL_PATH include)
math(EXPR SIZEOF_VOID_P_BITS "8 * ${CMAKE_SIZEOF_VOID_P}") math(EXPR SIZEOF_VOID_P_BITS "8 * ${CMAKE_SIZEOF_VOID_P}")
if(LIB_SUFFIX AND NOT SIZEOF_VOID_P_BITS EQUAL LIB_SUFFIX) if(LIB_SUFFIX AND NOT SIZEOF_VOID_P_BITS EQUAL LIB_SUFFIX)
set(OPENCV_CONFIG_INSTALL_PATH lib${LIB_SUFFIX}/cmake/opencv) set(OPENCV_CONFIG_INSTALL_PATH lib${LIB_SUFFIX}/cmake/opencv)
else() else()
set(OPENCV_CONFIG_INSTALL_PATH share/OpenCV) set(OPENCV_CONFIG_INSTALL_PATH share/OpenCV)
endif() endif()
endif() endif()
set(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/${OPENCV_LIB_INSTALL_PATH}") set(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/${OPENCV_LIB_INSTALL_PATH}")
@ -329,7 +324,7 @@ if(CMAKE_GENERATOR MATCHES "Makefiles|Ninja" AND "${CMAKE_BUILD_TYPE}" STREQUAL
set(CMAKE_BUILD_TYPE Release) set(CMAKE_BUILD_TYPE Release)
endif() endif()
include(cmake/OpenCVCompilerOptions.cmake REQUIRED) include(cmake/OpenCVCompilerOptions.cmake)
# ---------------------------------------------------------------------------- # ----------------------------------------------------------------------------
@ -337,7 +332,7 @@ include(cmake/OpenCVCompilerOptions.cmake REQUIRED)
# Default: dynamic # Default: dynamic
# ---------------------------------------------------------------------------- # ----------------------------------------------------------------------------
if(MSVC) if(MSVC)
include(cmake/OpenCVCRTLinkage.cmake REQUIRED) include(cmake/OpenCVCRTLinkage.cmake)
endif(MSVC) endif(MSVC)
if(WIN32 AND NOT MINGW) if(WIN32 AND NOT MINGW)
@ -370,17 +365,17 @@ if(UNIX)
endif() endif()
endif() endif()
include(cmake/OpenCVPCHSupport.cmake REQUIRED) include(cmake/OpenCVPCHSupport.cmake)
include(cmake/OpenCVModule.cmake REQUIRED) include(cmake/OpenCVModule.cmake)
# ---------------------------------------------------------------------------- # ----------------------------------------------------------------------------
# Detect 3rd-party libraries # Detect 3rd-party libraries
# ---------------------------------------------------------------------------- # ----------------------------------------------------------------------------
include(cmake/OpenCVFindLibsGrfmt.cmake REQUIRED) include(cmake/OpenCVFindLibsGrfmt.cmake)
include(cmake/OpenCVFindLibsGUI.cmake REQUIRED) include(cmake/OpenCVFindLibsGUI.cmake)
include(cmake/OpenCVFindLibsVideo.cmake REQUIRED) include(cmake/OpenCVFindLibsVideo.cmake)
include(cmake/OpenCVFindLibsPerf.cmake REQUIRED) include(cmake/OpenCVFindLibsPerf.cmake)
# ---------------------------------------------------------------------------- # ----------------------------------------------------------------------------
@ -389,21 +384,23 @@ include(cmake/OpenCVFindLibsPerf.cmake REQUIRED)
# --- LATEX for pdf documentation --- # --- LATEX for pdf documentation ---
if(BUILD_DOCS) if(BUILD_DOCS)
include(cmake/OpenCVFindLATEX.cmake REQUIRED) include(cmake/OpenCVFindLATEX.cmake)
endif(BUILD_DOCS) endif(BUILD_DOCS)
# --- Python Support --- # --- Python Support ---
include(cmake/OpenCVDetectPython.cmake REQUIRED) include(cmake/OpenCVDetectPython.cmake)
# --- Java Support --- # --- Java Support ---
include(cmake/OpenCVDetectApacheAnt.cmake)
if(ANDROID) if(ANDROID)
include(cmake/OpenCVDetectApacheAnt.cmake REQUIRED) include(cmake/OpenCVDetectAndroidSDK.cmake)
include(cmake/OpenCVDetectAndroidSDK.cmake REQUIRED)
if(NOT ANDROID_TOOLS_Pkg_Revision GREATER 13) if(NOT ANDROID_TOOLS_Pkg_Revision GREATER 13)
message(WARNING "OpenCV requires Android SDK tools revision 14 or newer. Otherwise tests and samples will no be compiled.") message(WARNING "OpenCV requires Android SDK tools revision 14 or newer. Otherwise tests and samples will no be compiled.")
endif() endif()
endif(ANDROID) elseif(ANT_EXECUTABLE)
find_package(JNI)
endif()
if(ANDROID AND ANDROID_EXECUTABLE AND ANT_EXECUTABLE AND (ANT_VERSION VERSION_GREATER 1.7) AND (ANDROID_TOOLS_Pkg_Revision GREATER 13)) if(ANDROID AND ANDROID_EXECUTABLE AND ANT_EXECUTABLE AND (ANT_VERSION VERSION_GREATER 1.7) AND (ANDROID_TOOLS_Pkg_Revision GREATER 13))
SET(CAN_BUILD_ANDROID_PROJECTS TRUE) SET(CAN_BUILD_ANDROID_PROJECTS TRUE)
@ -413,7 +410,7 @@ endif()
# --- OpenCL --- # --- OpenCL ---
if(WITH_OPENCL) if(WITH_OPENCL)
include(cmake/OpenCVDetectOpenCL.cmake REQUIRED) include(cmake/OpenCVDetectOpenCL.cmake)
if(OPENCL_FOUND) if(OPENCL_FOUND)
set(HAVE_OPENCL 1) set(HAVE_OPENCL 1)
endif() endif()
@ -434,7 +431,7 @@ if(ENABLE_SOLUTION_FOLDERS)
endif() endif()
# Extra OpenCV targets: uninstall, package_source, perf, etc. # Extra OpenCV targets: uninstall, package_source, perf, etc.
include(cmake/OpenCVExtraTargets.cmake REQUIRED) include(cmake/OpenCVExtraTargets.cmake)
# ---------------------------------------------------------------------------- # ----------------------------------------------------------------------------
@ -475,16 +472,16 @@ endif()
ocv_track_build_dependencies() ocv_track_build_dependencies()
# Generate platform-dependent and configuration-dependent headers # Generate platform-dependent and configuration-dependent headers
include(cmake/OpenCVGenHeaders.cmake REQUIRED) include(cmake/OpenCVGenHeaders.cmake)
# Generate opencv.pc for pkg-config command # Generate opencv.pc for pkg-config command
include(cmake/OpenCVGenPkgconfig.cmake REQUIRED) include(cmake/OpenCVGenPkgconfig.cmake)
# Generate OpenCV.mk for ndk-build (Android build tool) # Generate OpenCV.mk for ndk-build (Android build tool)
include(cmake/OpenCVGenAndroidMK.cmake REQUIRED) include(cmake/OpenCVGenAndroidMK.cmake)
# Generate OpenCVСonfig.cmake and OpenCVConfig-version.cmake for cmake projects # Generate OpenCVСonfig.cmake and OpenCVConfig-version.cmake for cmake projects
include(cmake/OpenCVGenConfig.cmake REQUIRED) include(cmake/OpenCVGenConfig.cmake)
# ---------------------------------------------------------------------------- # ----------------------------------------------------------------------------
@ -760,7 +757,7 @@ status(" Use Clp:" HAVE_CLP THEN YES ELSE NO)
if(HAVE_CUDA) if(HAVE_CUDA)
status("") status("")
status(" NVIDIA CUDA:" "(ver ${CUDA_VERSION_STRING})") status(" NVIDIA CUDA")
status(" Use CUFFT:" HAVE_CUFFT THEN YES ELSE NO) status(" Use CUFFT:" HAVE_CUFFT THEN YES ELSE NO)
status(" Use CUBLAS:" HAVE_CUBLAS THEN YES ELSE NO) status(" Use CUBLAS:" HAVE_CUBLAS THEN YES ELSE NO)
@ -774,9 +771,9 @@ status(" Python:")
status(" Interpreter:" PYTHON_EXECUTABLE THEN "${PYTHON_EXECUTABLE} (ver ${PYTHON_VERSION_FULL})" ELSE NO) status(" Interpreter:" PYTHON_EXECUTABLE THEN "${PYTHON_EXECUTABLE} (ver ${PYTHON_VERSION_FULL})" ELSE NO)
if(BUILD_opencv_python) if(BUILD_opencv_python)
if(PYTHONLIBS_VERSION_STRING) if(PYTHONLIBS_VERSION_STRING)
status(" Libraries:" HAVE_opencv_python THEN "${PYTHON_LIBRARIES} (ver ${PYTHONLIBS_VERSION_STRING})" ELSE NO) status(" Libraries:" HAVE_opencv_python THEN "${PYTHON_LIBRARIES} (ver ${PYTHONLIBS_VERSION_STRING})" ELSE NO)
else() else()
status(" Libraries:" HAVE_opencv_python THEN ${PYTHON_LIBRARIES} ELSE NO) status(" Libraries:" HAVE_opencv_python THEN ${PYTHON_LIBRARIES} ELSE NO)
endif() endif()
status(" numpy:" PYTHON_USE_NUMPY THEN "${PYTHON_NUMPY_INCLUDE_DIR} (ver ${PYTHON_NUMPY_VERSION})" ELSE "NO (Python wrappers can not be generated)") status(" numpy:" PYTHON_USE_NUMPY THEN "${PYTHON_NUMPY_INCLUDE_DIR} (ver ${PYTHON_NUMPY_VERSION})" ELSE "NO (Python wrappers can not be generated)")
status(" packages path:" PYTHON_EXECUTABLE THEN "${PYTHON_PACKAGES_PATH}" ELSE "-") status(" packages path:" PYTHON_EXECUTABLE THEN "${PYTHON_PACKAGES_PATH}" ELSE "-")

95
cmake/OpenCVCompilerOptions.cmake
Unescape View File

@ -124,35 +124,33 @@ if(CMAKE_COMPILER_IS_GNUCXX)
# SSE3 and further should be disabled under MingW because it generates compiler errors # SSE3 and further should be disabled under MingW because it generates compiler errors
if(NOT MINGW) if(NOT MINGW)
if(ENABLE_SSE3) if(ENABLE_AVX)
add_extra_compiler_option(-msse3) add_extra_compiler_option(-mavx)
endif() endif()
if(${CMAKE_OPENCV_GCC_VERSION_NUM} GREATER 402) # GCC depresses SSEx instructions when -mavx is used. Instead, it generates new AVX instructions or AVX equivalence for all SSEx instructions when needed.
set(HAVE_GCC43_OR_NEWER 1) if(NOT OPENCV_EXTRA_CXX_FLAGS MATCHES "-mavx")
endif() if(ENABLE_SSE3)
if(${CMAKE_OPENCV_GCC_VERSION_NUM} GREATER 401) add_extra_compiler_option(-msse3)
set(HAVE_GCC42_OR_NEWER 1) endif()
endif()
if(HAVE_GCC42_OR_NEWER OR APPLE)
if(ENABLE_SSSE3) if(ENABLE_SSSE3)
add_extra_compiler_option(-mssse3) add_extra_compiler_option(-mssse3)
endif() endif()
if(HAVE_GCC43_OR_NEWER OR APPLE)
if(ENABLE_SSE41) if(ENABLE_SSE41)
add_extra_compiler_option(-msse4.1) add_extra_compiler_option(-msse4.1)
endif() endif()
if(ENABLE_SSE42)
add_extra_compiler_option(-msse4.2) if(ENABLE_SSE42)
endif() add_extra_compiler_option(-msse4.2)
endif() endif()
endif() endif()
endif(NOT MINGW) endif(NOT MINGW)
if(X86 OR X86_64) if(X86 OR X86_64)
if(NOT APPLE AND CMAKE_SIZEOF_VOID_P EQUAL 4) if(NOT APPLE AND CMAKE_SIZEOF_VOID_P EQUAL 4)
if(ENABLE_SSE2) if(OPENCV_EXTRA_CXX_FLAGS MATCHES "-m(sse2|avx)")
add_extra_compiler_option(-mfpmath=sse)# !! important - be on the same wave with x64 compilers add_extra_compiler_option(-mfpmath=sse)# !! important - be on the same wave with x64 compilers
else() else()
add_extra_compiler_option(-mfpmath=387) add_extra_compiler_option(-mfpmath=387)
@ -201,30 +199,35 @@ if(MSVC)
set(OPENCV_EXTRA_FLAGS_RELEASE "${OPENCV_EXTRA_FLAGS_RELEASE} /Zi") set(OPENCV_EXTRA_FLAGS_RELEASE "${OPENCV_EXTRA_FLAGS_RELEASE} /Zi")
endif() endif()
if(NOT MSVC64) if(ENABLE_AVX AND NOT MSVC_VERSION LESS 1600)
# 64-bit MSVC compiler uses SSE/SSE2 by default set(OPENCV_EXTRA_FLAGS "${OPENCV_EXTRA_FLAGS} /arch:AVX")
if(ENABLE_SSE)
set(OPENCV_EXTRA_FLAGS "${OPENCV_EXTRA_FLAGS} /arch:SSE")
endif()
if(ENABLE_SSE2)
set(OPENCV_EXTRA_FLAGS "${OPENCV_EXTRA_FLAGS} /arch:SSE2")
endif()
endif() endif()
if(ENABLE_SSE3) if(ENABLE_SSE4_1 AND CV_ICC AND NOT OPENCV_EXTRA_FLAGS MATCHES "/arch:")
set(OPENCV_EXTRA_FLAGS "${OPENCV_EXTRA_FLAGS} /arch:SSE4.1")
endif()
if(ENABLE_SSE3 AND CV_ICC AND NOT OPENCV_EXTRA_FLAGS MATCHES "/arch:")
set(OPENCV_EXTRA_FLAGS "${OPENCV_EXTRA_FLAGS} /arch:SSE3") set(OPENCV_EXTRA_FLAGS "${OPENCV_EXTRA_FLAGS} /arch:SSE3")
endif() endif()
if(ENABLE_SSE4_1)
set(OPENCV_EXTRA_FLAGS "${OPENCV_EXTRA_FLAGS} /arch:SSE4.1") if(NOT MSVC64)
# 64-bit MSVC compiler uses SSE/SSE2 by default
if(ENABLE_SSE2 AND NOT OPENCV_EXTRA_FLAGS MATCHES "/arch:")
set(OPENCV_EXTRA_FLAGS "${OPENCV_EXTRA_FLAGS} /arch:SSE2")
endif()
if(ENABLE_SSE AND NOT OPENCV_EXTRA_FLAGS MATCHES "/arch:")
set(OPENCV_EXTRA_FLAGS "${OPENCV_EXTRA_FLAGS} /arch:SSE")
endif()
endif() endif()
if(ENABLE_SSE OR ENABLE_SSE2 OR ENABLE_SSE3 OR ENABLE_SSE4_1) if(ENABLE_SSE OR ENABLE_SSE2 OR ENABLE_SSE3 OR ENABLE_SSE4_1 OR ENABLE_AVX)
set(OPENCV_EXTRA_FLAGS "${OPENCV_EXTRA_FLAGS} /Oi") set(OPENCV_EXTRA_FLAGS "${OPENCV_EXTRA_FLAGS} /Oi")
endif() endif()
if(X86 OR X86_64) if(X86 OR X86_64)
if(CMAKE_SIZEOF_VOID_P EQUAL 4 AND ENABLE_SSE2) if(CMAKE_SIZEOF_VOID_P EQUAL 4 AND ENABLE_SSE2)
set(OPENCV_EXTRA_FLAGS "${OPENCV_EXTRA_FLAGS} /fp:fast")# !! important - be on the same wave with x64 compilers set(OPENCV_EXTRA_FLAGS "${OPENCV_EXTRA_FLAGS} /fp:fast") # !! important - be on the same wave with x64 compilers
endif() endif()
endif() endif()
endif() endif()
@ -238,34 +241,34 @@ endif()
# Add user supplied extra options (optimization, etc...) # Add user supplied extra options (optimization, etc...)
# ========================================================== # ==========================================================
set(OPENCV_EXTRA_FLAGS "${OPENCV_EXTRA_FLAGS}" CACHE INTERNAL "Extra compiler options") set(OPENCV_EXTRA_FLAGS "${OPENCV_EXTRA_FLAGS}" CACHE INTERNAL "Extra compiler options")
set(OPENCV_EXTRA_C_FLAGS "${OPENCV_EXTRA_C_FLAGS}" CACHE INTERNAL "Extra compiler options for C sources") set(OPENCV_EXTRA_C_FLAGS "${OPENCV_EXTRA_C_FLAGS}" CACHE INTERNAL "Extra compiler options for C sources")
set(OPENCV_EXTRA_CXX_FLAGS "${OPENCV_EXTRA_CXX_FLAGS}" CACHE INTERNAL "Extra compiler options for C++ sources") set(OPENCV_EXTRA_CXX_FLAGS "${OPENCV_EXTRA_CXX_FLAGS}" CACHE INTERNAL "Extra compiler options for C++ sources")
set(OPENCV_EXTRA_FLAGS_RELEASE "${OPENCV_EXTRA_FLAGS_RELEASE}" CACHE INTERNAL "Extra compiler options for Release build") set(OPENCV_EXTRA_FLAGS_RELEASE "${OPENCV_EXTRA_FLAGS_RELEASE}" CACHE INTERNAL "Extra compiler options for Release build")
set(OPENCV_EXTRA_FLAGS_DEBUG "${OPENCV_EXTRA_FLAGS_DEBUG}" CACHE INTERNAL "Extra compiler options for Debug build") set(OPENCV_EXTRA_FLAGS_DEBUG "${OPENCV_EXTRA_FLAGS_DEBUG}" CACHE INTERNAL "Extra compiler options for Debug build")
set(OPENCV_EXTRA_EXE_LINKER_FLAGS "${OPENCV_EXTRA_EXE_LINKER_FLAGS}" CACHE INTERNAL "Extra linker flags") set(OPENCV_EXTRA_EXE_LINKER_FLAGS "${OPENCV_EXTRA_EXE_LINKER_FLAGS}" CACHE INTERNAL "Extra linker flags")
set(OPENCV_EXTRA_EXE_LINKER_FLAGS_RELEASE "${OPENCV_EXTRA_EXE_LINKER_FLAGS_RELEASE}" CACHE INTERNAL "Extra linker flags for Release build") set(OPENCV_EXTRA_EXE_LINKER_FLAGS_RELEASE "${OPENCV_EXTRA_EXE_LINKER_FLAGS_RELEASE}" CACHE INTERNAL "Extra linker flags for Release build")
set(OPENCV_EXTRA_EXE_LINKER_FLAGS_DEBUG "${OPENCV_EXTRA_EXE_LINKER_FLAGS_DEBUG}" CACHE INTERNAL "Extra linker flags for Debug build") set(OPENCV_EXTRA_EXE_LINKER_FLAGS_DEBUG "${OPENCV_EXTRA_EXE_LINKER_FLAGS_DEBUG}" CACHE INTERNAL "Extra linker flags for Debug build")
#combine all "extra" options #combine all "extra" options
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${OPENCV_EXTRA_FLAGS} ${OPENCV_EXTRA_C_FLAGS}") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${OPENCV_EXTRA_FLAGS} ${OPENCV_EXTRA_C_FLAGS}")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${OPENCV_EXTRA_FLAGS} ${OPENCV_EXTRA_CXX_FLAGS}") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${OPENCV_EXTRA_FLAGS} ${OPENCV_EXTRA_CXX_FLAGS}")
set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} ${OPENCV_EXTRA_FLAGS_RELEASE}") set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} ${OPENCV_EXTRA_FLAGS_RELEASE}")
set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} ${OPENCV_EXTRA_FLAGS_RELEASE}") set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} ${OPENCV_EXTRA_FLAGS_RELEASE}")
set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} ${OPENCV_EXTRA_FLAGS_DEBUG}") set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} ${OPENCV_EXTRA_FLAGS_DEBUG}")
set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} ${OPENCV_EXTRA_FLAGS_DEBUG}") set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} ${OPENCV_EXTRA_FLAGS_DEBUG}")
set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${OPENCV_EXTRA_EXE_LINKER_FLAGS}") set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${OPENCV_EXTRA_EXE_LINKER_FLAGS}")
set(CMAKE_EXE_LINKER_FLAGS_RELEASE "${CMAKE_EXE_LINKER_FLAGS_RELEASE} ${OPENCV_EXTRA_EXE_LINKER_FLAGS_RELEASE}") set(CMAKE_EXE_LINKER_FLAGS_RELEASE "${CMAKE_EXE_LINKER_FLAGS_RELEASE} ${OPENCV_EXTRA_EXE_LINKER_FLAGS_RELEASE}")
set(CMAKE_EXE_LINKER_FLAGS_DEBUG "${CMAKE_EXE_LINKER_FLAGS_DEBUG} ${OPENCV_EXTRA_EXE_LINKER_FLAGS_DEBUG}") set(CMAKE_EXE_LINKER_FLAGS_DEBUG "${CMAKE_EXE_LINKER_FLAGS_DEBUG} ${OPENCV_EXTRA_EXE_LINKER_FLAGS_DEBUG}")
if(MSVC) if(MSVC)
# avoid warnings from MSVC about overriding the /W* option # avoid warnings from MSVC about overriding the /W* option
# we replace /W3 with /W4 only for C++ files, # we replace /W3 with /W4 only for C++ files,
# since all the 3rd-party libraries OpenCV uses are in C, # since all the 3rd-party libraries OpenCV uses are in C,
# and we do not care about their warnings. # and we do not care about their warnings.
string(REPLACE "/W3" "/W4" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}") string(REPLACE "/W3" "/W4" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
string(REPLACE "/W3" "/W4" CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE}") string(REPLACE "/W3" "/W4" CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE}")
string(REPLACE "/W3" "/W4" CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG}") string(REPLACE "/W3" "/W4" CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG}")
if(NOT ENABLE_NOISY_WARNINGS AND MSVC_VERSION EQUAL 1400) if(NOT ENABLE_NOISY_WARNINGS AND MSVC_VERSION EQUAL 1400)
ocv_warnings_disable(CMAKE_CXX_FLAGS /wd4510 /wd4610 /wd4312 /wd4201 /wd4244 /wd4328 /wd4267) ocv_warnings_disable(CMAKE_CXX_FLAGS /wd4510 /wd4610 /wd4312 /wd4201 /wd4244 /wd4328 /wd4267)
@ -274,7 +277,7 @@ if(MSVC)
# allow extern "C" functions throw exceptions # allow extern "C" functions throw exceptions
foreach(flags CMAKE_C_FLAGS CMAKE_C_FLAGS_RELEASE CMAKE_C_FLAGS_RELEASE CMAKE_CXX_FLAGS CMAKE_CXX_FLAGS_RELEASE CMAKE_CXX_FLAGS_DEBUG) foreach(flags CMAKE_C_FLAGS CMAKE_C_FLAGS_RELEASE CMAKE_C_FLAGS_RELEASE CMAKE_CXX_FLAGS CMAKE_CXX_FLAGS_RELEASE CMAKE_CXX_FLAGS_DEBUG)
string(REPLACE "/EHsc-" "/EHs" ${flags} "${${flags}}") string(REPLACE "/EHsc-" "/EHs" ${flags} "${${flags}}")
string(REPLACE "/EHsc" "/EHs" ${flags} "${${flags}}") string(REPLACE "/EHsc" "/EHs" ${flags} "${${flags}}")
string(REPLACE "/Zm1000" "" ${flags} "${${flags}}") string(REPLACE "/Zm1000" "" ${flags} "${${flags}}")
endforeach() endforeach()

4
cmake/OpenCVDetectCXXCompiler.cmake
Unescape View File

@ -89,8 +89,8 @@ if(CMAKE_COMPILER_IS_GNUCXX)
endif() endif()
endif() endif()
if(CMAKE_SYSTEM_PROCESSOR MATCHES amd64.*|x86_64.* OR CMAKE_GENERATOR MATCHES "Visual Studio.*Win64") if(CMAKE_SYSTEM_PROCESSOR MATCHES "amd64.*|x86_64.*|AMD64.*" OR CMAKE_GENERATOR MATCHES "Visual Studio.*Win64")
set(X86_64 1) set(X86_64 1)
elseif(CMAKE_SYSTEM_PROCESSOR MATCHES i686.*|i386.*|x86.*) elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "i686.*|i386.*|x86.*|amd64.*|AMD64.*")
set(X86 1) set(X86 1)
endif() endif()

4
cmake/OpenCVFindLibsPerf.cmake
Unescape View File

@ -4,7 +4,7 @@
# --- TBB --- # --- TBB ---
if(WITH_TBB) if(WITH_TBB)
include("${OpenCV_SOURCE_DIR}/cmake/OpenCVDetectTBB.cmake" REQUIRED) include("${OpenCV_SOURCE_DIR}/cmake/OpenCVDetectTBB.cmake")
endif(WITH_TBB) endif(WITH_TBB)
# --- IPP --- # --- IPP ---
@ -21,7 +21,7 @@ endif(WITH_IPP)
# --- CUDA --- # --- CUDA ---
if(WITH_CUDA) if(WITH_CUDA)
include("${OpenCV_SOURCE_DIR}/cmake/OpenCVDetectCUDA.cmake" REQUIRED) include("${OpenCV_SOURCE_DIR}/cmake/OpenCVDetectCUDA.cmake")
endif(WITH_CUDA) endif(WITH_CUDA)
# --- Eigen --- # --- Eigen ---

2
cmake/OpenCVFindLibsVideo.cmake
Unescape View File

@ -98,7 +98,7 @@ endif(WITH_XIMEA)
ocv_clear_vars(HAVE_FFMPEG HAVE_FFMPEG_CODEC HAVE_FFMPEG_FORMAT HAVE_FFMPEG_UTIL HAVE_FFMPEG_SWSCALE HAVE_GENTOO_FFMPEG HAVE_FFMPEG_FFMPEG) ocv_clear_vars(HAVE_FFMPEG HAVE_FFMPEG_CODEC HAVE_FFMPEG_FORMAT HAVE_FFMPEG_UTIL HAVE_FFMPEG_SWSCALE HAVE_GENTOO_FFMPEG HAVE_FFMPEG_FFMPEG)
if(WITH_FFMPEG) if(WITH_FFMPEG)
if(WIN32) if(WIN32)
include("${OpenCV_SOURCE_DIR}/3rdparty/ffmpeg/ffmpeg_version.cmake" REQUIRED) include("${OpenCV_SOURCE_DIR}/3rdparty/ffmpeg/ffmpeg_version.cmake")
elseif(UNIX) elseif(UNIX)
CHECK_MODULE(libavcodec HAVE_FFMPEG_CODEC) CHECK_MODULE(libavcodec HAVE_FFMPEG_CODEC)
CHECK_MODULE(libavformat HAVE_FFMPEG_FORMAT) CHECK_MODULE(libavformat HAVE_FFMPEG_FORMAT)

67
modules/core/include/opencv2/core/internal.hpp
Unescape View File

@ -104,69 +104,72 @@ CV_INLINE IppiSize ippiSize(int width, int height)
} }
#endif #endif
#if defined __SSE2__ || (defined _MSC_VER && _MSC_VER >= 1300) #ifndef IPPI_CALL
# define IPPI_CALL(func) CV_Assert((func) >= 0)
#endif
#if defined __SSE2__ || defined _M_X64 || (defined _M_IX86_FP && _M_IX86_FP >= 2)
# include "emmintrin.h" # include "emmintrin.h"
# define CV_SSE 1 # define CV_SSE 1
# define CV_SSE2 1 # define CV_SSE2 1
# if defined __SSE3__ || (defined _MSC_VER && _MSC_VER >= 1500) # if defined __SSE3__ || (defined _MSC_VER && _MSC_VER >= 1500)
# include "pmmintrin.h" # include "pmmintrin.h"
# define CV_SSE3 1 # define CV_SSE3 1
# else
# define CV_SSE3 0
# endif # endif
# if defined __SSSE3__ # if defined __SSSE3__ || (defined _MSC_VER && _MSC_VER >= 1500)
# include "tmmintrin.h" # include "tmmintrin.h"
# define CV_SSSE3 1 # define CV_SSSE3 1
# else
# define CV_SSSE3 0
# endif # endif
# if defined __SSE4_1__ || (defined _MSC_VER && _MSC_VER >= 1500) # if defined __SSE4_1__ || (defined _MSC_VER && _MSC_VER >= 1500)
# include <smmintrin.h> # include <smmintrin.h>
# define CV_SSE4_1 1 # define CV_SSE4_1 1
# else
# define CV_SSE4_1 0
# endif # endif
# if defined __SSE4_2__ || (defined _MSC_VER && _MSC_VER >= 1500) # if defined __SSE4_2__ || (defined _MSC_VER && _MSC_VER >= 1500)
# include <nmmintrin.h> # include <nmmintrin.h>
# define CV_SSE4_2 1 # define CV_SSE4_2 1
# else
# define CV_SSE4_2 0
# endif # endif
# if defined __AVX__ || (defined _MSC_FULL_VER && _MSC_FULL_VER >= 160040219) # if defined __AVX__ || (defined _MSC_FULL_VER && _MSC_FULL_VER >= 160040219)
# include <immintrin.h> // MS Visual Studio 2010 (2012?) has no macro pre-defined to identify the use of /arch:AVX
// See: http://connect.microsoft.com/VisualStudio/feedback/details/605858/arch-avx-should-define-a-predefined-macro-in-x64-and-set-a-unique-value-for-m-ix86-fp-in-win32
# include <immintrin.h>
# define CV_AVX 1 # define CV_AVX 1
# if defined(_XCR_XFEATURE_ENABLED_MASK) # if defined(_XCR_XFEATURE_ENABLED_MASK)
# define __xgetbv() _xgetbv(_XCR_XFEATURE_ENABLED_MASK) # define __xgetbv() _xgetbv(_XCR_XFEATURE_ENABLED_MASK)
# else # else
# define __xgetbv() 0 # define __xgetbv() 0
# endif # endif
# else
# define CV_AVX 0
# endif # endif
# else #endif
#ifdef __ARM_NEON__
# include <arm_neon.h>
# define CV_NEON 1
# define CPU_HAS_NEON_FEATURE (true)
#endif
#ifndef CV_SSE
# define CV_SSE 0 # define CV_SSE 0
#endif
#ifndef CV_SSE2
# define CV_SSE2 0 # define CV_SSE2 0
#endif
#ifndef CV_SSE3
# define CV_SSE3 0 # define CV_SSE3 0
#endif
#ifndef CV_SSSE3
# define CV_SSSE3 0 # define CV_SSSE3 0
#endif
#ifndef CV_SSE4_1
# define CV_SSE4_1 0 # define CV_SSE4_1 0
#endif
#ifndef CV_SSE4_2
# define CV_SSE4_2 0 # define CV_SSE4_2 0
#endif
#ifndef CV_AVX
# define CV_AVX 0 # define CV_AVX 0
# endif
#if defined ANDROID && defined __ARM_NEON__
# include "arm_neon.h"
# define CV_NEON 1
# define CPU_HAS_NEON_FEATURE (true)
//TODO: make real check using stuff from "cpu-features.h"
//((bool)android_getCpuFeatures() & ANDROID_CPU_ARM_FEATURE_NEON)
#else
# define CV_NEON 0
# define CPU_HAS_NEON_FEATURE (false)
#endif #endif
#ifndef CV_NEON
#ifndef IPPI_CALL # define CV_NEON 0
# define IPPI_CALL(func) CV_Assert((func) >= 0)
#endif #endif
#ifdef HAVE_TBB #ifdef HAVE_TBB

2
modules/core/test/test_operations.cpp
Unescape View File

@ -774,7 +774,7 @@ bool CV_OperationsTest::TestTemplateMat()
Mat m2 = Mat::zeros(10, 10, CV_8UC3); Mat m2 = Mat::zeros(10, 10, CV_8UC3);
m1.copyTo(m2.row(1)); m1.copyTo(m2.row(1));
} }
catch(const Exception& e) catch(const Exception&)
{ {
badarg_catched = true; badarg_catched = true;
} }

2
modules/gpu/perf/perf_imgproc.cpp
Unescape View File

@ -1739,7 +1739,7 @@ PERF_TEST_P(Method_Sz, ImgProc_GeneralizedHough, Combine(
for (int i = 0; i < objCount; ++i) for (int i = 0; i < objCount; ++i)
{ {
double scale = rng.uniform(0.7, 1.3); double scale = rng.uniform(0.7, 1.3);
bool rotate = rng.uniform(0, 2); bool rotate = 1 == rng.uniform(0, 2);
cv::Mat obj; cv::Mat obj;
cv::resize(templ, obj, cv::Size(), scale, scale); cv::resize(templ, obj, cv::Size(), scale, scale);

10
modules/imgproc/test/test_imgwarp_strict.cpp
Unescape View File

@ -433,7 +433,7 @@ void CV_Resize_Test::run_reference_func()
double CV_Resize_Test::getWeight(double a, double b, int x) double CV_Resize_Test::getWeight(double a, double b, int x)
{ {
float w = std::min(static_cast<double>(x + 1), b) - std::max(static_cast<double>(x), a); double w = std::min(static_cast<double>(x + 1), b) - std::max(static_cast<double>(x), a);
CV_Assert(w >= 0); CV_Assert(w >= 0);
return w; return w;
} }
@ -514,7 +514,7 @@ void CV_Resize_Test::resize_1d(const Mat& _src, Mat& _dst, int dy, const dim& _d
else if (interpolation == INTER_LINEAR || interpolation == INTER_CUBIC || interpolation == INTER_LANCZOS4) else if (interpolation == INTER_LINEAR || interpolation == INTER_CUBIC || interpolation == INTER_LANCZOS4)
{ {
internal::interpolate_method inter_func = internal::inter_array[interpolation - (interpolation == INTER_LANCZOS4 ? 2 : 1)]; internal::interpolate_method inter_func = internal::inter_array[interpolation - (interpolation == INTER_LANCZOS4 ? 2 : 1)];
int elemsize = _src.elemSize(); size_t elemsize = _src.elemSize();
int ofs = 0, ksize = 2; int ofs = 0, ksize = 2;
if (interpolation == INTER_CUBIC) if (interpolation == INTER_CUBIC)
@ -557,10 +557,10 @@ void CV_Resize_Test::resize_1d(const Mat& _src, Mat& _dst, int dy, const dim& _d
void CV_Resize_Test::generate_buffer(double scale, dim& _dim) void CV_Resize_Test::generate_buffer(double scale, dim& _dim)
{ {
int length = _dim.size(); size_t length = _dim.size();
for (int dx = 0; dx < length; ++dx) for (size_t dx = 0; dx < length; ++dx)
{ {
double fsx = scale * (dx + 0.5f) - 0.5f; double fsx = scale * (dx + 0.5) - 0.5;
int isx = cvFloor(fsx); int isx = cvFloor(fsx);
_dim[dx] = std::make_pair(isx, fsx - isx); _dim[dx] = std::make_pair(isx, fsx - isx);
} }

45
modules/java/CMakeLists.txt
Unescape View File

@ -1,14 +1,23 @@
# ---------------------------------------------------------------------------- # ----------------------------------------------------------------------------
# CMake file for java support # CMake file for java support
# ---------------------------------------------------------------------------- # ----------------------------------------------------------------------------
if(NOT ANDROID OR NOT PYTHON_EXECUTABLE OR ANDROID_NATIVE_API_LEVEL LESS 8) if(IOS OR NOT PYTHON_EXECUTABLE OR NOT (JNI_FOUND OR (ANDROID AND ANDROID_NATIVE_API_LEVEL GREATER 7)))
ocv_module_disable(java) ocv_module_disable(java)
endif() endif()
if(NOT ANDROID)
# disable java by default because java support on desktop is experimental
set(BUILD_opencv_java_INIT OFF)
endif()
set(the_description "The java bindings") set(the_description "The java bindings")
ocv_add_module(java BINDINGS opencv_core opencv_imgproc OPTIONAL opencv_objdetect opencv_features2d opencv_video opencv_highgui opencv_ml opencv_calib3d opencv_photo opencv_nonfree opencv_contrib) ocv_add_module(java BINDINGS opencv_core opencv_imgproc OPTIONAL opencv_objdetect opencv_features2d opencv_video opencv_highgui opencv_ml opencv_calib3d opencv_photo opencv_nonfree opencv_contrib)
ocv_module_include_directories("${CMAKE_CURRENT_SOURCE_DIR}/generator/src/cpp") ocv_module_include_directories("${CMAKE_CURRENT_SOURCE_DIR}/generator/src/cpp")
if(NOT ANDROID)
include_directories(${JNI_INCLUDE_DIRS})
endif()
# get list of modules to wrap # get list of modules to wrap
string(REPLACE "opencv_" "" OPENCV_JAVA_MODULES "${OPENCV_MODULE_${the_module}_REQ_DEPS};${OPENCV_MODULE_${the_module}_OPT_DEPS}") string(REPLACE "opencv_" "" OPENCV_JAVA_MODULES "${OPENCV_MODULE_${the_module}_REQ_DEPS};${OPENCV_MODULE_${the_module}_OPT_DEPS}")
foreach(module ${OPENCV_JAVA_MODULES}) foreach(module ${OPENCV_JAVA_MODULES})
@ -123,7 +132,12 @@ set(JNI_INSTALL_ROOT "sdk/native")
# copy each documented header to the final destination # copy each documented header to the final destination
set(java_files "") set(java_files "")
foreach(java_file ${documented_java_files} ${handwrittren_aidl_sources}) set(source_java_files ${documented_java_files} ${handwrittren_aidl_sources})
if(NOT ANDROID)
ocv_list_filterout(source_java_files "/(engine|android)\\\\+")
endif()
foreach(java_file ${source_java_files})
get_filename_component(java_file_name "${java_file}" NAME) get_filename_component(java_file_name "${java_file}" NAME)
string(REPLACE "-jdoc.java" ".java" java_file_name "${java_file_name}") string(REPLACE "-jdoc.java" ".java" java_file_name "${java_file_name}")
string(REPLACE "+" "/" java_file_name "${java_file_name}") string(REPLACE "+" "/" java_file_name "${java_file_name}")
@ -173,8 +187,11 @@ set_target_properties(${the_module} PROPERTIES
LINK_INTERFACE_LIBRARIES "" LINK_INTERFACE_LIBRARIES ""
) )
install(TARGETS ${the_module} LIBRARY DESTINATION ${OPENCV_LIB_INSTALL_PATH} COMPONENT main) install(TARGETS ${the_module}
LIBRARY DESTINATION ${OPENCV_LIB_INSTALL_PATH} COMPONENT main
ARCHIVE DESTINATION ${OPENCV_LIB_INSTALL_PATH} COMPONENT main)
set(lib_target ${the_module}_library)
if(ANDROID) if(ANDROID)
target_link_libraries(${the_module} jnigraphics) # for Mat <=> Bitmap converters target_link_libraries(${the_module} jnigraphics) # for Mat <=> Bitmap converters
@ -223,8 +240,6 @@ if(ANDROID)
# create Android library project in build folder # create Android library project in build folder
if(ANDROID_EXECUTABLE) if(ANDROID_EXECUTABLE)
set(lib_target ${the_module}_android_library)
set(lib_target_files ${ANDROID_LIB_PROJECT_FILES}) set(lib_target_files ${ANDROID_LIB_PROJECT_FILES})
ocv_list_add_prefix(lib_target_files "${OpenCV_BINARY_DIR}/") ocv_list_add_prefix(lib_target_files "${OpenCV_BINARY_DIR}/")
@ -263,12 +278,26 @@ if(ANDROID)
endif() endif()
add_custom_target(${lib_target} SOURCES ${lib_proj_files} ${lib_target_files} "${OpenCV_BINARY_DIR}/${ANDROID_MANIFEST_FILE}") add_custom_target(${lib_target} SOURCES ${lib_proj_files} ${lib_target_files} "${OpenCV_BINARY_DIR}/${ANDROID_MANIFEST_FILE}")
add_dependencies(${lib_target} ${api_target})
add_dependencies(${the_module} ${lib_target})
endif() endif()
else(ANDROID)
configure_file("${CMAKE_CURRENT_SOURCE_DIR}/jar/build.xml" "${OpenCV_BINARY_DIR}/build.xml" IMMEDIATE @ONLY)
set(JAR_NAME opencv-${OPENCV_VERSION_MAJOR}.${OPENCV_VERSION_MINOR}.${OPENCV_VERSION_PATCH}.jar)
add_custom_command(
OUTPUT "${OpenCV_BINARY_DIR}/bin/${JAR_NAME}" "${OpenCV_BINARY_DIR}/bin/.${JAR_NAME}.dephelper"
COMMAND ${ANT_EXECUTABLE} -q -noinput -k jar
COMMAND ${CMAKE_COMMAND} -E touch "${OpenCV_BINARY_DIR}/bin/.${JAR_NAME}.dephelper"
WORKING_DIRECTORY "${OpenCV_BINARY_DIR}"
DEPENDS "${OpenCV_BINARY_DIR}/build.xml" ${java_files}
COMMENT "Generating ${JAR_NAME}"
)
add_custom_target(${lib_target} SOURCES "${OpenCV_BINARY_DIR}/bin/${JAR_NAME}")
endif(ANDROID) endif(ANDROID)
add_dependencies(${lib_target} ${api_target})
add_dependencies(${the_module} ${lib_target})
#android test project #android test project
if(ANDROID AND BUILD_TESTS) if(ANDROID AND BUILD_TESTS)
add_subdirectory(android_test) add_subdirectory(android_test)

20
modules/java/generator/gen_java.py
Unescape View File

@ -462,8 +462,10 @@ JNIEXPORT jdoubleArray JNICALL Java_org_opencv_core_Core_n_1getTextSize
env->SetDoubleArrayRegion(result, 0, 2, fill); env->SetDoubleArrayRegion(result, 0, 2, fill);
if (baseLine != NULL) if (baseLine != NULL) {
env->SetIntArrayRegion(baseLine, 0, 1, pbaseLine); jint jbaseLine = (jint)(*pbaseLine);
env->SetIntArrayRegion(baseLine, 0, 1, &jbaseLine);
}
return result; return result;
@ -871,14 +873,18 @@ public class %(jc)s {
#include "converters.h" #include "converters.h"
#ifdef DEBUG #if defined DEBUG && defined ANDROID
#include <android/log.h> # include <android/log.h>
#define MODULE_LOG_TAG "OpenCV.%(m)s" # define MODULE_LOG_TAG "OpenCV.%(m)s"
#define LOGD(...) ((void)__android_log_print(ANDROID_LOG_DEBUG, MODULE_LOG_TAG, __VA_ARGS__)) # define LOGD(...) ((void)__android_log_print(ANDROID_LOG_DEBUG, MODULE_LOG_TAG, __VA_ARGS__))
#else //DEBUG #else //DEBUG
#define LOGD(...) # define LOGD(...)
#endif //DEBUG #endif //DEBUG
#ifdef _MSC_VER
# pragma warning(disable:4800 4244)
#endif
#include "opencv2/%(m)s/%(m)s.hpp" #include "opencv2/%(m)s/%(m)s.hpp"
using namespace cv; using namespace cv;

25
modules/java/generator/src/cpp/Mat.cpp
Unescape View File

@ -2,6 +2,8 @@
#include "converters.h" #include "converters.h"
#ifdef ANDROID
#include <android/log.h> #include <android/log.h>
#define LOG_TAG "org.opencv.core.Mat" #define LOG_TAG "org.opencv.core.Mat"
#define LOGE(...) ((void)__android_log_print(ANDROID_LOG_ERROR, LOG_TAG, __VA_ARGS__)) #define LOGE(...) ((void)__android_log_print(ANDROID_LOG_ERROR, LOG_TAG, __VA_ARGS__))
@ -11,6 +13,15 @@
#define LOGD(...) #define LOGD(...)
#endif //DEBUG #endif //DEBUG
#else
#define LOGE(...)
#define LOGD(...)
#endif
#ifdef _MSC_VER
# pragma warning(disable:4800)
#endif
#include "opencv2/core/core.hpp" #include "opencv2/core/core.hpp"
using namespace cv; using namespace cv;
@ -2163,7 +2174,7 @@ template<typename T> static int mat_put(cv::Mat* m, int row, int col, int count,
if(! buff) return 0; if(! buff) return 0;
count *= sizeof(T); count *= sizeof(T);
int rest = ((m->rows - row) * m->cols - col) * m->elemSize(); int rest = ((m->rows - row) * m->cols - col) * (int)m->elemSize();
if(count>rest) count = rest; if(count>rest) count = rest;
int res = count; int res = count;
@ -2172,14 +2183,14 @@ template<typename T> static int mat_put(cv::Mat* m, int row, int col, int count,
memcpy(m->ptr(row, col), buff, count); memcpy(m->ptr(row, col), buff, count);
} else { } else {
// row by row // row by row
int num = (m->cols - col) * m->elemSize(); // 1st partial row int num = (m->cols - col) * (int)m->elemSize(); // 1st partial row
if(count<num) num = count; if(count<num) num = count;
uchar* data = m->ptr(row++, col); uchar* data = m->ptr(row++, col);
while(count>0){ while(count>0){
memcpy(data, buff, num); memcpy(data, buff, num);
count -= num; count -= num;
buff += num; buff += num;
num = m->cols * m->elemSize(); num = m->cols * (int)m->elemSize();
if(count<num) num = count; if(count<num) num = count;
data = m->ptr(row++, 0); data = m->ptr(row++, 0);
} }
@ -2323,7 +2334,7 @@ template<typename T> int mat_get(cv::Mat* m, int row, int col, int count, char*
if(! buff) return 0; if(! buff) return 0;
int bytesToCopy = count * sizeof(T); int bytesToCopy = count * sizeof(T);
int bytesRestInMat = ((m->rows - row) * m->cols - col) * m->elemSize(); int bytesRestInMat = ((m->rows - row) * m->cols - col) * (int)m->elemSize();
if(bytesToCopy > bytesRestInMat) bytesToCopy = bytesRestInMat; if(bytesToCopy > bytesRestInMat) bytesToCopy = bytesRestInMat;
int res = bytesToCopy; int res = bytesToCopy;
@ -2332,7 +2343,7 @@ template<typename T> int mat_get(cv::Mat* m, int row, int col, int count, char*
memcpy(buff, m->ptr(row, col), bytesToCopy); memcpy(buff, m->ptr(row, col), bytesToCopy);
} else { } else {
// row by row // row by row
int bytesInRow = (m->cols - col) * m->elemSize(); // 1st partial row int bytesInRow = (m->cols - col) * (int)m->elemSize(); // 1st partial row
while(bytesToCopy > 0) while(bytesToCopy > 0)
{ {
int len = std::min(bytesToCopy, bytesInRow); int len = std::min(bytesToCopy, bytesInRow);
@ -2341,7 +2352,7 @@ template<typename T> int mat_get(cv::Mat* m, int row, int col, int count, char*
buff += len; buff += len;
row++; row++;
col = 0; col = 0;
bytesInRow = m->cols * m->elemSize(); bytesInRow = m->cols * (int)m->elemSize();
} }
} }
return res; return res;
@ -2518,7 +2529,7 @@ JNIEXPORT jdoubleArray JNICALL Java_org_opencv_core_Mat_nGet
jdoubleArray res = env->NewDoubleArray(me->channels()); jdoubleArray res = env->NewDoubleArray(me->channels());
if(res){ if(res){
jdouble buff[me->channels()]; jdouble buff[CV_CN_MAX];//me->channels()
int i; int i;
switch(me->depth()){ switch(me->depth()){
case CV_8U: for(i=0; i<me->channels(); i++) buff[i] = *((unsigned char*) me->ptr(row, col) + i); break; case CV_8U: for(i=0; i<me->channels(); i++) buff[i] = *((unsigned char*) me->ptr(row, col) + i); break;

10
modules/java/generator/src/cpp/converters.cpp
Unescape View File

@ -198,12 +198,12 @@ void Mat_to_vector_KeyPoint(Mat& mat, vector<KeyPoint>& v_kp)
void vector_KeyPoint_to_Mat(vector<KeyPoint>& v_kp, Mat& mat) void vector_KeyPoint_to_Mat(vector<KeyPoint>& v_kp, Mat& mat)
{ {
int count = v_kp.size(); int count = (int)v_kp.size();
mat.create(count, 1, CV_32FC(7)); mat.create(count, 1, CV_32FC(7));
for(int i=0; i<count; i++) for(int i=0; i<count; i++)
{ {
KeyPoint kp = v_kp[i]; KeyPoint kp = v_kp[i];
mat.at< Vec<float, 7> >(i, 0) = Vec<float, 7>(kp.pt.x, kp.pt.y, kp.size, kp.angle, kp.response, kp.octave, kp.class_id); mat.at< Vec<float, 7> >(i, 0) = Vec<float, 7>(kp.pt.x, kp.pt.y, kp.size, kp.angle, kp.response, (float)kp.octave, (float)kp.class_id);
} }
} }
#endif #endif
@ -231,7 +231,7 @@ void Mat_to_vector_Mat(cv::Mat& mat, std::vector<cv::Mat>& v_mat)
void vector_Mat_to_Mat(std::vector<cv::Mat>& v_mat, cv::Mat& mat) void vector_Mat_to_Mat(std::vector<cv::Mat>& v_mat, cv::Mat& mat)
{ {
int count = v_mat.size(); int count = (int)v_mat.size();
mat.create(count, 1, CV_32SC2); mat.create(count, 1, CV_32SC2);
for(int i=0; i<count; i++) for(int i=0; i<count; i++)
{ {
@ -258,12 +258,12 @@ void Mat_to_vector_DMatch(Mat& mat, vector<DMatch>& v_dm)
void vector_DMatch_to_Mat(vector<DMatch>& v_dm, Mat& mat) void vector_DMatch_to_Mat(vector<DMatch>& v_dm, Mat& mat)
{ {
int count = v_dm.size(); int count = (int)v_dm.size();
mat.create(count, 1, CV_32FC4); mat.create(count, 1, CV_32FC4);
for(int i=0; i<count; i++) for(int i=0; i<count; i++)
{ {
DMatch dm = v_dm[i]; DMatch dm = v_dm[i];
mat.at< Vec<float, 4> >(i, 0) = Vec<float, 4>(dm.queryIdx, dm.trainIdx, dm.imgIdx, dm.distance); mat.at< Vec<float, 4> >(i, 0) = Vec<float, 4>((float)dm.queryIdx, (float)dm.trainIdx, (float)dm.imgIdx, dm.distance);
} }
} }
#endif #endif

2
modules/java/generator/src/cpp/features2d_manual.hpp
Unescape View File

@ -6,6 +6,8 @@
#ifdef HAVE_OPENCV_FEATURES2D #ifdef HAVE_OPENCV_FEATURES2D
#include "opencv2/features2d/features2d.hpp" #include "opencv2/features2d/features2d.hpp"
#undef SIMPLEBLOB // to solve conflict with wincrypt.h on windows
namespace cv namespace cv
{ {

4
modules/java/generator/src/cpp/utils.cpp
Unescape View File

@ -3,6 +3,8 @@
#include "opencv2/core/core.hpp" #include "opencv2/core/core.hpp"
#include "opencv2/imgproc/imgproc.hpp" #include "opencv2/imgproc/imgproc.hpp"
#ifdef ANDROID
#include <android/bitmap.h> #include <android/bitmap.h>
#include <android/log.h> #include <android/log.h>
@ -165,3 +167,5 @@ JNIEXPORT void JNICALL Java_org_opencv_android_Utils_nMatToBitmap
} }
} // extern "C" } // extern "C"
#endif //ANDROID

15
modules/java/jar/build.xml
Unescape View File

@ -0,0 +1,15 @@
<!-- This is an Apache Ant build file. As part of the desktop java build -->
<!-- process, this config is used to package the autogenerated .java -->
<!-- interface files into OpenCV.jar -->
<project name="OpenCV">
<target name="jar">
<!-- This is to make a jar with a source attachment, for e.g. easy -->
<!-- navigation in Eclipse. See this question: -->
<!-- http://stackoverflow.com/questions/3584968/ant-how-to-compile-jar-that-includes-source-attachment -->
<javac sourcepath="" srcdir="src" destdir="src" debug="on" includeantruntime="false" >
<include name="**/*.java"/>
</javac>
<jar basedir="src" destfile="bin/opencv-@OPENCV_VERSION_MAJOR@.@OPENCV_VERSION_MINOR@.@OPENCV_VERSION_PATCH@.jar"/>
</target>
</project>

776
modules/objdetect/src/haar.cpp
Unescape View File

@ -45,7 +45,6 @@
#include <stdio.h> #include <stdio.h>
#include "opencv2/core/internal.hpp" #include "opencv2/core/internal.hpp"
#if CV_SSE2 || CV_SSE3 #if CV_SSE2 || CV_SSE3
# if !CV_SSE4_1 && !CV_SSE4_2 # if !CV_SSE4_1 && !CV_SSE4_2
# define _mm_blendv_pd(a, b, m) _mm_xor_pd(a, _mm_and_pd(_mm_xor_pd(b, a), m)) # define _mm_blendv_pd(a, b, m) _mm_xor_pd(a, _mm_and_pd(_mm_xor_pd(b, a), m))
@ -53,13 +52,13 @@
# endif # endif
#endif #endif
# if CV_AVX #if CV_AVX
# define CV_HAAR_USE_AVX 1 # define CV_HAAR_USE_AVX 1
# else #else
# if CV_SSE2 || CV_SSE3 # if CV_SSE2 || CV_SSE3
# define CV_HAAR_USE_SSE 1 # define CV_HAAR_USE_SSE 1
# endif # endif
# endif #endif
/* these settings affect the quality of detection: change with care */ /* these settings affect the quality of detection: change with care */
#define CV_ADJUST_FEATURES 1 #define CV_ADJUST_FEATURES 1
@ -76,8 +75,7 @@ typedef struct CvHidHaarFeature
float weight; float weight;
} }
rect[CV_HAAR_FEATURE_MAX]; rect[CV_HAAR_FEATURE_MAX];
} } CvHidHaarFeature;
CvHidHaarFeature;
typedef struct CvHidHaarTreeNode typedef struct CvHidHaarTreeNode
@ -86,8 +84,7 @@ typedef struct CvHidHaarTreeNode
float threshold; float threshold;
int left; int left;
int right; int right;
} } CvHidHaarTreeNode;
CvHidHaarTreeNode;
typedef struct CvHidHaarClassifier typedef struct CvHidHaarClassifier
@ -96,8 +93,7 @@ typedef struct CvHidHaarClassifier
//CvHaarFeature* orig_feature; //CvHaarFeature* orig_feature;
CvHidHaarTreeNode* node; CvHidHaarTreeNode* node;
float* alpha; float* alpha;
} } CvHidHaarClassifier;
CvHidHaarClassifier;
typedef struct CvHidHaarStageClassifier typedef struct CvHidHaarStageClassifier
@ -110,11 +106,10 @@ typedef struct CvHidHaarStageClassifier
struct CvHidHaarStageClassifier* next; struct CvHidHaarStageClassifier* next;
struct CvHidHaarStageClassifier* child; struct CvHidHaarStageClassifier* child;
struct CvHidHaarStageClassifier* parent; struct CvHidHaarStageClassifier* parent;
} } CvHidHaarStageClassifier;
CvHidHaarStageClassifier;
struct CvHidHaarClassifierCascade typedef struct CvHidHaarClassifierCascade
{ {
int count; int count;
int isStumpBased; int isStumpBased;
@ -127,7 +122,7 @@ struct CvHidHaarClassifierCascade
sumtype *p0, *p1, *p2, *p3; sumtype *p0, *p1, *p2, *p3;
void** ipp_stages; void** ipp_stages;
}; } CvHidHaarClassifierCascade;
const int icv_object_win_border = 1; const int icv_object_win_border = 1;
@ -634,21 +629,21 @@ cvSetImagesForHaarClassifierCascade( CvHaarClassifierCascade* _cascade,
} }
//AVX version icvEvalHidHaarClassifier. Process 8 CvHidHaarClassifiers per call. Check AVX support before invocation!! // AVX version icvEvalHidHaarClassifier. Process 8 CvHidHaarClassifiers per call. Check AVX support before invocation!!
#ifdef CV_HAAR_USE_AVX #ifdef CV_HAAR_USE_AVX
CV_INLINE CV_INLINE
double icvEvalHidHaarClassifierAVX( CvHidHaarClassifier* classifier, double icvEvalHidHaarClassifierAVX( CvHidHaarClassifier* classifier,
double variance_norm_factor, size_t p_offset ) double variance_norm_factor, size_t p_offset )
{ {
int CV_DECL_ALIGNED(32) idxV[8] = {0,0,0,0,0,0,0,0}; int CV_DECL_ALIGNED(32) idxV[8] = {0,0,0,0,0,0,0,0};
char flags[8] = {0,0,0,0,0,0,0,0}; uchar flags[8] = {0,0,0,0,0,0,0,0};
CvHidHaarTreeNode* nodes[8]; CvHidHaarTreeNode* nodes[8];
double res = 0; double res = 0;
char exitConditionFlag = 0; uchar exitConditionFlag = 0;
for(;;) for(;;)
{ {
float CV_DECL_ALIGNED(32) tmp[8] = {0,0,0,0,0,0,0,0}; float CV_DECL_ALIGNED(32) tmp[8] = {0,0,0,0,0,0,0,0};
nodes[0] = classifier ->node + idxV[0]; nodes[0] = (classifier+0)->node + idxV[0];
nodes[1] = (classifier+1)->node + idxV[1]; nodes[1] = (classifier+1)->node + idxV[1];
nodes[2] = (classifier+2)->node + idxV[2]; nodes[2] = (classifier+2)->node + idxV[2];
nodes[3] = (classifier+3)->node + idxV[3]; nodes[3] = (classifier+3)->node + idxV[3];
@ -658,46 +653,79 @@ double icvEvalHidHaarClassifierAVX( CvHidHaarClassifier* classifier,
nodes[7] = (classifier+7)->node + idxV[7]; nodes[7] = (classifier+7)->node + idxV[7];
__m256 t = _mm256_set1_ps(variance_norm_factor); __m256 t = _mm256_set1_ps(variance_norm_factor);
t = _mm256_mul_ps(t, _mm256_set_ps(nodes[7]->threshold,nodes[6]->threshold,nodes[5]->threshold,nodes[4]->threshold,nodes[3]->threshold,nodes[2]->threshold,nodes[1]->threshold,nodes[0]->threshold));
__m256 offset = _mm256_set_ps(calc_sum(nodes[7]->feature.rect[0],p_offset), calc_sum(nodes[6]->feature.rect[0],p_offset), calc_sum(nodes[5]->feature.rect[0],p_offset), t = _mm256_mul_ps(t, _mm256_set_ps(nodes[7]->threshold,
calc_sum(nodes[4]->feature.rect[0],p_offset), calc_sum(nodes[3]->feature.rect[0],p_offset), calc_sum(nodes[2]->feature.rect[0],p_offset), calc_sum(nodes[1]->feature.rect[0], nodes[6]->threshold,
p_offset),calc_sum(nodes[0]->feature.rect[0],p_offset)); nodes[5]->threshold,
__m256 weight = _mm256_set_ps(nodes[7]->feature.rect[0].weight, nodes[6]->feature.rect[0].weight, nodes[5]->feature.rect[0].weight, nodes[4]->threshold,
nodes[4]->feature.rect[0].weight, nodes[3]->feature.rect[0].weight, nodes[2]->feature.rect[0].weight, nodes[1]->feature.rect[0].weight, nodes[0]->feature.rect[0].weight); nodes[3]->threshold,
__m256 sum = _mm256_mul_ps(offset, weight); nodes[2]->threshold,
nodes[1]->threshold,
nodes[0]->threshold));
__m256 offset = _mm256_set_ps(calc_sum(nodes[7]->feature.rect[0], p_offset),
calc_sum(nodes[6]->feature.rect[0], p_offset),
calc_sum(nodes[5]->feature.rect[0], p_offset),
calc_sum(nodes[4]->feature.rect[0], p_offset),
calc_sum(nodes[3]->feature.rect[0], p_offset),
calc_sum(nodes[2]->feature.rect[0], p_offset),
calc_sum(nodes[1]->feature.rect[0], p_offset),
calc_sum(nodes[0]->feature.rect[0], p_offset));
__m256 weight = _mm256_set_ps(nodes[7]->feature.rect[0].weight,
nodes[6]->feature.rect[0].weight,
nodes[5]->feature.rect[0].weight,
nodes[4]->feature.rect[0].weight,
nodes[3]->feature.rect[0].weight,
nodes[2]->feature.rect[0].weight,
nodes[1]->feature.rect[0].weight,
nodes[0]->feature.rect[0].weight);
offset = _mm256_set_ps(calc_sum(nodes[7]->feature.rect[1],p_offset),calc_sum(nodes[6]->feature.rect[1],p_offset),calc_sum(nodes[5]->feature.rect[1],p_offset), __m256 sum = _mm256_mul_ps(offset, weight);
calc_sum(nodes[4]->feature.rect[1],p_offset),calc_sum(nodes[3]->feature.rect[1],p_offset),calc_sum(nodes[2]->feature.rect[1],p_offset),calc_sum(nodes[1]->feature.rect[1],p_offset),
calc_sum(nodes[0]->feature.rect[1],p_offset));
weight = _mm256_set_ps(nodes[7]->feature.rect[1].weight, nodes[6]->feature.rect[1].weight, nodes[5]->feature.rect[1].weight, nodes[4]->feature.rect[1].weight,
nodes[3]->feature.rect[1].weight, nodes[2]->feature.rect[1].weight, nodes[1]->feature.rect[1].weight, nodes[0]->feature.rect[1].weight);
sum = _mm256_add_ps(sum, _mm256_mul_ps(offset,weight)); offset = _mm256_set_ps(calc_sum(nodes[7]->feature.rect[1], p_offset),
calc_sum(nodes[6]->feature.rect[1], p_offset),
calc_sum(nodes[5]->feature.rect[1], p_offset),
calc_sum(nodes[4]->feature.rect[1], p_offset),
calc_sum(nodes[3]->feature.rect[1], p_offset),
calc_sum(nodes[2]->feature.rect[1], p_offset),
calc_sum(nodes[1]->feature.rect[1], p_offset),
calc_sum(nodes[0]->feature.rect[1], p_offset));
weight = _mm256_set_ps(nodes[7]->feature.rect[1].weight,
nodes[6]->feature.rect[1].weight,
nodes[5]->feature.rect[1].weight,
nodes[4]->feature.rect[1].weight,
nodes[3]->feature.rect[1].weight,
nodes[2]->feature.rect[1].weight,
nodes[1]->feature.rect[1].weight,
nodes[0]->feature.rect[1].weight);
sum = _mm256_add_ps(sum, _mm256_mul_ps(offset, weight));
if( nodes[0]->feature.rect[2].p0 ) if( nodes[0]->feature.rect[2].p0 )
tmp[0] = calc_sum(nodes[0]->feature.rect[2],p_offset) * nodes[0]->feature.rect[2].weight; tmp[0] = calc_sum(nodes[0]->feature.rect[2], p_offset) * nodes[0]->feature.rect[2].weight;
if( nodes[1]->feature.rect[2].p0 ) if( nodes[1]->feature.rect[2].p0 )
tmp[1] = calc_sum(nodes[1]->feature.rect[2],p_offset) * nodes[1]->feature.rect[2].weight; tmp[1] = calc_sum(nodes[1]->feature.rect[2], p_offset) * nodes[1]->feature.rect[2].weight;
if( nodes[2]->feature.rect[2].p0 ) if( nodes[2]->feature.rect[2].p0 )
tmp[2] = calc_sum(nodes[2]->feature.rect[2],p_offset) * nodes[2]->feature.rect[2].weight; tmp[2] = calc_sum(nodes[2]->feature.rect[2], p_offset) * nodes[2]->feature.rect[2].weight;
if( nodes[3]->feature.rect[2].p0 ) if( nodes[3]->feature.rect[2].p0 )
tmp[3] = calc_sum(nodes[3]->feature.rect[2],p_offset) * nodes[3]->feature.rect[2].weight; tmp[3] = calc_sum(nodes[3]->feature.rect[2], p_offset) * nodes[3]->feature.rect[2].weight;
if( nodes[4]->feature.rect[2].p0 ) if( nodes[4]->feature.rect[2].p0 )
tmp[4] = calc_sum(nodes[4]->feature.rect[2],p_offset) * nodes[4]->feature.rect[2].weight; tmp[4] = calc_sum(nodes[4]->feature.rect[2], p_offset) * nodes[4]->feature.rect[2].weight;
if( nodes[5]->feature.rect[2].p0 ) if( nodes[5]->feature.rect[2].p0 )
tmp[5] = calc_sum(nodes[5]->feature.rect[2],p_offset) * nodes[5]->feature.rect[2].weight; tmp[5] = calc_sum(nodes[5]->feature.rect[2], p_offset) * nodes[5]->feature.rect[2].weight;
if( nodes[6]->feature.rect[2].p0 ) if( nodes[6]->feature.rect[2].p0 )
tmp[6] = calc_sum(nodes[6]->feature.rect[2],p_offset) * nodes[6]->feature.rect[2].weight; tmp[6] = calc_sum(nodes[6]->feature.rect[2], p_offset) * nodes[6]->feature.rect[2].weight;
if( nodes[7]->feature.rect[2].p0 ) if( nodes[7]->feature.rect[2].p0 )
tmp[7] = calc_sum(nodes[7]->feature.rect[2],p_offset) * nodes[7]->feature.rect[2].weight; tmp[7] = calc_sum(nodes[7]->feature.rect[2], p_offset) * nodes[7]->feature.rect[2].weight;
sum = _mm256_add_ps(sum,_mm256_load_ps(tmp)); sum = _mm256_add_ps(sum,_mm256_load_ps(tmp));
__m256 left = _mm256_set_ps(nodes[7]->left,nodes[6]->left,nodes[5]->left,nodes[4]->left,nodes[3]->left,nodes[2]->left,nodes[1]->left,nodes[0]->left); __m256 left = _mm256_set_ps(nodes[7]->left, nodes[6]->left, nodes[5]->left, nodes[4]->left, nodes[3]->left, nodes[2]->left, nodes[1]->left, nodes[0]->left );
__m256 right = _mm256_set_ps(nodes[7]->right,nodes[6]->right,nodes[5]->right,nodes[4]->right,nodes[3]->right,nodes[2]->right,nodes[1]->right,nodes[0]->right); __m256 right = _mm256_set_ps(nodes[7]->right,nodes[6]->right,nodes[5]->right,nodes[4]->right,nodes[3]->right,nodes[2]->right,nodes[1]->right,nodes[0]->right);
_mm256_store_si256((__m256i*)idxV,_mm256_cvttps_epi32(_mm256_blendv_ps(right, left,_mm256_cmp_ps(sum, t, _CMP_LT_OQ )))); _mm256_store_si256((__m256i*)idxV, _mm256_cvttps_epi32(_mm256_blendv_ps(right, left, _mm256_cmp_ps(sum, t, _CMP_LT_OQ))));
for(int i = 0; i < 8; i++) for(int i = 0; i < 8; i++)
{ {
@ -706,17 +734,17 @@ double icvEvalHidHaarClassifierAVX( CvHidHaarClassifier* classifier,
if(!flags[i]) if(!flags[i])
{ {
exitConditionFlag++; exitConditionFlag++;
flags[i]=1; flags[i] = 1;
res+=((classifier+i)->alpha[-idxV[i]]); res += (classifier+i)->alpha[-idxV[i]];
} }
idxV[i]=0; idxV[i]=0;
} }
} }
if(exitConditionFlag==8) if(exitConditionFlag == 8)
return res; return res;
} }
} }
#endif #endif //CV_HAAR_USE_AVX
CV_INLINE CV_INLINE
double icvEvalHidHaarClassifier( CvHidHaarClassifier* classifier, double icvEvalHidHaarClassifier( CvHidHaarClassifier* classifier,
@ -778,18 +806,16 @@ static int
cvRunHaarClassifierCascadeSum( const CvHaarClassifierCascade* _cascade, cvRunHaarClassifierCascadeSum( const CvHaarClassifierCascade* _cascade,
CvPoint pt, double& stage_sum, int start_stage ) CvPoint pt, double& stage_sum, int start_stage )
{ {
#ifdef CV_HAAR_USE_AVX #ifdef CV_HAAR_USE_AVX
bool haveAVX = false; bool haveAVX = false;
if(cv::checkHardwareSupport(CV_CPU_AVX)) if(cv::checkHardwareSupport(CV_CPU_AVX))
if(__xgetbv()&0x6)// Check if the OS will save the YMM registers if(__xgetbv()&0x6)// Check if the OS will save the YMM registers
{ haveAVX = true;
haveAVX = true; #else
} # ifdef CV_HAAR_USE_SSE
#else bool haveSSE2 = cv::checkHardwareSupport(CV_CPU_SSE2);
#ifdef CV_HAAR_USE_SSE # endif
bool haveSSE2 = cv::checkHardwareSupport(CV_CPU_SSE2); #endif
#endif
#endif
int p_offset, pq_offset; int p_offset, pq_offset;
int i, j; int i, j;
@ -828,19 +854,20 @@ cvRunHaarClassifierCascadeSum( const CvHaarClassifierCascade* _cascade,
while( ptr ) while( ptr )
{ {
stage_sum = 0.0; stage_sum = 0.0;
j = 0;
#ifdef CV_HAAR_USE_AVX #ifdef CV_HAAR_USE_AVX
if(haveAVX) if(haveAVX)
{ {
for( ; j < cascade->stage_classifier[i].count-8; j+=8 ) for( ; j <= ptr->count - 8; j += 8 )
{ {
stage_sum += icvEvalHidHaarClassifierAVX( stage_sum += icvEvalHidHaarClassifierAVX(
cascade->stage_classifier[i].classifier+j, ptr->classifier + j,
variance_norm_factor, p_offset ); variance_norm_factor, p_offset );
} }
} }
#endif #endif
for( j = 0; j < ptr->count; j++ ) for( ; j < ptr->count; j++ )
{ {
stage_sum += icvEvalHidHaarClassifier( ptr->classifier + j, variance_norm_factor, p_offset ); stage_sum += icvEvalHidHaarClassifier( ptr->classifier + j, variance_norm_factor, p_offset );
} }
@ -860,283 +887,369 @@ cvRunHaarClassifierCascadeSum( const CvHaarClassifierCascade* _cascade,
} }
else if( cascade->isStumpBased ) else if( cascade->isStumpBased )
{ {
#ifdef CV_HAAR_USE_AVX #ifdef CV_HAAR_USE_AVX
if(haveAVX) if(haveAVX)
{
CvHidHaarClassifier* classifiers[8];
CvHidHaarTreeNode* nodes[8];
for( i = start_stage; i < cascade->count; i++ )
{ {
CvHidHaarClassifier* classifiers[8]; stage_sum = 0.0;
CvHidHaarTreeNode* nodes[8]; j = 0;
for( i = start_stage; i < cascade->count; i++ ) float CV_DECL_ALIGNED(32) buf[8];
if( cascade->stage_classifier[i].two_rects )
{ {
stage_sum = 0.0; for( ; j <= cascade->stage_classifier[i].count - 8; j += 8 )
j = 0;
float CV_DECL_ALIGNED(32) buf[8];
if( cascade->stage_classifier[i].two_rects )
{ {
for( ; j <= cascade->stage_classifier[i].count-8; j+=8 ) classifiers[0] = cascade->stage_classifier[i].classifier + j;
{ nodes[0] = classifiers[0]->node;
//__m256 stage_sumPart = _mm256_setzero_ps(); classifiers[1] = cascade->stage_classifier[i].classifier + j + 1;
classifiers[0] = cascade->stage_classifier[i].classifier + j; nodes[1] = classifiers[1]->node;
nodes[0] = classifiers[0]->node; classifiers[2] = cascade->stage_classifier[i].classifier + j + 2;
classifiers[1] = cascade->stage_classifier[i].classifier + j + 1; nodes[2] = classifiers[2]->node;
nodes[1] = classifiers[1]->node; classifiers[3] = cascade->stage_classifier[i].classifier + j + 3;
classifiers[2] = cascade->stage_classifier[i].classifier + j + 2; nodes[3] = classifiers[3]->node;
nodes[2]= classifiers[2]->node; classifiers[4] = cascade->stage_classifier[i].classifier + j + 4;
classifiers[3] = cascade->stage_classifier[i].classifier + j + 3; nodes[4] = classifiers[4]->node;
nodes[3] = classifiers[3]->node; classifiers[5] = cascade->stage_classifier[i].classifier + j + 5;
classifiers[4] = cascade->stage_classifier[i].classifier + j + 4; nodes[5] = classifiers[5]->node;
nodes[4] = classifiers[4]->node; classifiers[6] = cascade->stage_classifier[i].classifier + j + 6;
classifiers[5] = cascade->stage_classifier[i].classifier + j + 5; nodes[6] = classifiers[6]->node;
nodes[5] = classifiers[5]->node; classifiers[7] = cascade->stage_classifier[i].classifier + j + 7;
classifiers[6] = cascade->stage_classifier[i].classifier + j + 6; nodes[7] = classifiers[7]->node;
nodes[6] = classifiers[6]->node;
classifiers[7] = cascade->stage_classifier[i].classifier + j + 7; __m256 t = _mm256_set1_ps(variance_norm_factor);
nodes[7] = classifiers[7]->node; t = _mm256_mul_ps(t, _mm256_set_ps(nodes[7]->threshold,
nodes[6]->threshold,
__m256 t = _mm256_set1_ps(variance_norm_factor); nodes[5]->threshold,
t = _mm256_mul_ps(t, _mm256_set_ps(nodes[7]->threshold,nodes[6]->threshold,nodes[5]->threshold,nodes[4]->threshold,nodes[3]->threshold,nodes[2]->threshold,nodes[1]->threshold,nodes[0]->threshold)); nodes[4]->threshold,
nodes[3]->threshold,
__m256 offset = _mm256_set_ps(calc_sum(nodes[7]->feature.rect[0],p_offset), calc_sum(nodes[6]->feature.rect[0],p_offset), calc_sum(nodes[5]->feature.rect[0],p_offset), nodes[2]->threshold,
calc_sum(nodes[4]->feature.rect[0],p_offset), calc_sum(nodes[3]->feature.rect[0],p_offset), calc_sum(nodes[2]->feature.rect[0],p_offset), calc_sum(nodes[1]->feature.rect[0], nodes[1]->threshold,
p_offset),calc_sum(nodes[0]->feature.rect[0],p_offset)); nodes[0]->threshold));
__m256 weight = _mm256_set_ps(nodes[7]->feature.rect[0].weight, nodes[6]->feature.rect[0].weight, nodes[5]->feature.rect[0].weight,
nodes[4]->feature.rect[0].weight, nodes[3]->feature.rect[0].weight, nodes[2]->feature.rect[0].weight, nodes[1]->feature.rect[0].weight, nodes[0]->feature.rect[0].weight); __m256 offset = _mm256_set_ps(calc_sum(nodes[7]->feature.rect[0], p_offset),
__m256 sum = _mm256_mul_ps(offset, weight); calc_sum(nodes[6]->feature.rect[0], p_offset),
calc_sum(nodes[5]->feature.rect[0], p_offset),
offset = _mm256_set_ps(calc_sum(nodes[7]->feature.rect[1],p_offset),calc_sum(nodes[6]->feature.rect[1],p_offset),calc_sum(nodes[5]->feature.rect[1],p_offset), calc_sum(nodes[4]->feature.rect[0], p_offset),
calc_sum(nodes[4]->feature.rect[1],p_offset),calc_sum(nodes[3]->feature.rect[1],p_offset),calc_sum(nodes[2]->feature.rect[1],p_offset),calc_sum(nodes[1]->feature.rect[1],p_offset), calc_sum(nodes[3]->feature.rect[0], p_offset),
calc_sum(nodes[0]->feature.rect[1],p_offset)); calc_sum(nodes[2]->feature.rect[0], p_offset),
weight = _mm256_set_ps(nodes[7]->feature.rect[1].weight, nodes[6]->feature.rect[1].weight, nodes[5]->feature.rect[1].weight, nodes[4]->feature.rect[1].weight, calc_sum(nodes[1]->feature.rect[0], p_offset),
nodes[3]->feature.rect[1].weight, nodes[2]->feature.rect[1].weight, nodes[1]->feature.rect[1].weight, nodes[0]->feature.rect[1].weight); calc_sum(nodes[0]->feature.rect[0], p_offset));
sum = _mm256_add_ps(sum, _mm256_mul_ps(offset,weight));
__m256 weight = _mm256_set_ps(nodes[7]->feature.rect[0].weight,
__m256 alpha0 = _mm256_set_ps(classifiers[7]->alpha[0],classifiers[6]->alpha[0],classifiers[5]->alpha[0],classifiers[4]->alpha[0],classifiers[3]->alpha[0], nodes[6]->feature.rect[0].weight,
classifiers[2]->alpha[0],classifiers[1]->alpha[0],classifiers[0]->alpha[0]); nodes[5]->feature.rect[0].weight,
__m256 alpha1 = _mm256_set_ps(classifiers[7]->alpha[1],classifiers[6]->alpha[1],classifiers[5]->alpha[1],classifiers[4]->alpha[1],classifiers[3]->alpha[1], nodes[4]->feature.rect[0].weight,
classifiers[2]->alpha[1],classifiers[1]->alpha[1],classifiers[0]->alpha[1]); nodes[3]->feature.rect[0].weight,
nodes[2]->feature.rect[0].weight,
_mm256_store_ps(buf, _mm256_blendv_ps(alpha0, alpha1, _mm256_cmp_ps(t, sum, _CMP_LE_OQ ))); nodes[1]->feature.rect[0].weight,
stage_sum+=(buf[0]+buf[1]+buf[2]+buf[3]+buf[4]+buf[5]+buf[6]+buf[7]); nodes[0]->feature.rect[0].weight);
} __m256 sum = _mm256_mul_ps(offset, weight);
offset = _mm256_set_ps(calc_sum(nodes[7]->feature.rect[1], p_offset),
calc_sum(nodes[6]->feature.rect[1], p_offset),
calc_sum(nodes[5]->feature.rect[1], p_offset),
calc_sum(nodes[4]->feature.rect[1], p_offset),
calc_sum(nodes[3]->feature.rect[1], p_offset),
calc_sum(nodes[2]->feature.rect[1], p_offset),
calc_sum(nodes[1]->feature.rect[1], p_offset),
calc_sum(nodes[0]->feature.rect[1], p_offset));
weight = _mm256_set_ps(nodes[7]->feature.rect[1].weight,
nodes[6]->feature.rect[1].weight,
nodes[5]->feature.rect[1].weight,
nodes[4]->feature.rect[1].weight,
nodes[3]->feature.rect[1].weight,
nodes[2]->feature.rect[1].weight,
nodes[1]->feature.rect[1].weight,
nodes[0]->feature.rect[1].weight);
sum = _mm256_add_ps(sum, _mm256_mul_ps(offset,weight));
__m256 alpha0 = _mm256_set_ps(classifiers[7]->alpha[0],
classifiers[6]->alpha[0],
classifiers[5]->alpha[0],
classifiers[4]->alpha[0],
classifiers[3]->alpha[0],
classifiers[2]->alpha[0],
classifiers[1]->alpha[0],
classifiers[0]->alpha[0]);
__m256 alpha1 = _mm256_set_ps(classifiers[7]->alpha[1],
classifiers[6]->alpha[1],
classifiers[5]->alpha[1],
classifiers[4]->alpha[1],
classifiers[3]->alpha[1],
classifiers[2]->alpha[1],
classifiers[1]->alpha[1],
classifiers[0]->alpha[1]);
_mm256_store_ps(buf, _mm256_blendv_ps(alpha0, alpha1, _mm256_cmp_ps(t, sum, _CMP_LE_OQ)));
stage_sum += (buf[0]+buf[1]+buf[2]+buf[3]+buf[4]+buf[5]+buf[6]+buf[7]);
}
for( ; j < cascade->stage_classifier[i].count; j++ ) for( ; j < cascade->stage_classifier[i].count; j++ )
{ {
CvHidHaarClassifier* classifier = cascade->stage_classifier[i].classifier + j; CvHidHaarClassifier* classifier = cascade->stage_classifier[i].classifier + j;
CvHidHaarTreeNode* node = classifier->node; CvHidHaarTreeNode* node = classifier->node;
double t = node->threshold*variance_norm_factor; double t = node->threshold*variance_norm_factor;
double sum = calc_sum(node->feature.rect[0],p_offset) * node->feature.rect[0].weight; double sum = calc_sum(node->feature.rect[0],p_offset) * node->feature.rect[0].weight;
sum += calc_sum(node->feature.rect[1],p_offset) * node->feature.rect[1].weight; sum += calc_sum(node->feature.rect[1],p_offset) * node->feature.rect[1].weight;
stage_sum += classifier->alpha[sum >= t]; stage_sum += classifier->alpha[sum >= t];
}
} }
else }
else
{
for( ; j <= (cascade->stage_classifier[i].count)-8; j+=8 )
{ {
for( ; j <= (cascade->stage_classifier[i].count)-8; j+=8 ) float CV_DECL_ALIGNED(32) tmp[8] = {0,0,0,0,0,0,0,0};
{
float CV_DECL_ALIGNED(32) tmp[8] = {0,0,0,0,0,0,0,0}; classifiers[0] = cascade->stage_classifier[i].classifier + j;
nodes[0] = classifiers[0]->node;
classifiers[0] = cascade->stage_classifier[i].classifier + j; classifiers[1] = cascade->stage_classifier[i].classifier + j + 1;
nodes[0] = classifiers[0]->node; nodes[1] = classifiers[1]->node;
classifiers[1] = cascade->stage_classifier[i].classifier + j + 1; classifiers[2] = cascade->stage_classifier[i].classifier + j + 2;
nodes[1] = classifiers[1]->node; nodes[2] = classifiers[2]->node;
classifiers[2] = cascade->stage_classifier[i].classifier + j + 2; classifiers[3] = cascade->stage_classifier[i].classifier + j + 3;
nodes[2]= classifiers[2]->node; nodes[3] = classifiers[3]->node;
classifiers[3] = cascade->stage_classifier[i].classifier + j + 3; classifiers[4] = cascade->stage_classifier[i].classifier + j + 4;
nodes[3] = classifiers[3]->node; nodes[4] = classifiers[4]->node;
classifiers[4] = cascade->stage_classifier[i].classifier + j + 4; classifiers[5] = cascade->stage_classifier[i].classifier + j + 5;
nodes[4] = classifiers[4]->node; nodes[5] = classifiers[5]->node;
classifiers[5] = cascade->stage_classifier[i].classifier + j + 5; classifiers[6] = cascade->stage_classifier[i].classifier + j + 6;
nodes[5] = classifiers[5]->node; nodes[6] = classifiers[6]->node;
classifiers[6] = cascade->stage_classifier[i].classifier + j + 6; classifiers[7] = cascade->stage_classifier[i].classifier + j + 7;
nodes[6] = classifiers[6]->node; nodes[7] = classifiers[7]->node;
classifiers[7] = cascade->stage_classifier[i].classifier + j + 7;
nodes[7] = classifiers[7]->node; __m256 t = _mm256_set1_ps(variance_norm_factor);
__m256 t = _mm256_set1_ps(variance_norm_factor); t = _mm256_mul_ps(t, _mm256_set_ps(nodes[7]->threshold,
t = _mm256_mul_ps(t, _mm256_set_ps(nodes[7]->threshold,nodes[6]->threshold,nodes[5]->threshold,nodes[4]->threshold,nodes[3]->threshold,nodes[2]->threshold,nodes[1]->threshold,nodes[0]->threshold)); nodes[6]->threshold,
nodes[5]->threshold,
__m256 offset = _mm256_set_ps(calc_sum(nodes[7]->feature.rect[0],p_offset), calc_sum(nodes[6]->feature.rect[0],p_offset), calc_sum(nodes[5]->feature.rect[0],p_offset), nodes[4]->threshold,
calc_sum(nodes[4]->feature.rect[0],p_offset), calc_sum(nodes[3]->feature.rect[0],p_offset), calc_sum(nodes[2]->feature.rect[0],p_offset), calc_sum(nodes[1]->feature.rect[0], nodes[3]->threshold,
p_offset),calc_sum(nodes[0]->feature.rect[0],p_offset)); nodes[2]->threshold,
__m256 weight = _mm256_set_ps(nodes[7]->feature.rect[0].weight, nodes[6]->feature.rect[0].weight, nodes[5]->feature.rect[0].weight, nodes[1]->threshold,
nodes[4]->feature.rect[0].weight, nodes[3]->feature.rect[0].weight, nodes[2]->feature.rect[0].weight, nodes[1]->feature.rect[0].weight, nodes[0]->feature.rect[0].weight); nodes[0]->threshold));
__m256 sum = _mm256_mul_ps(offset, weight);
__m256 offset = _mm256_set_ps(calc_sum(nodes[7]->feature.rect[0], p_offset),
offset = _mm256_set_ps(calc_sum(nodes[7]->feature.rect[1],p_offset),calc_sum(nodes[6]->feature.rect[1],p_offset),calc_sum(nodes[5]->feature.rect[1],p_offset), calc_sum(nodes[6]->feature.rect[0], p_offset),
calc_sum(nodes[4]->feature.rect[1],p_offset),calc_sum(nodes[3]->feature.rect[1],p_offset),calc_sum(nodes[2]->feature.rect[1],p_offset),calc_sum(nodes[1]->feature.rect[1],p_offset), calc_sum(nodes[5]->feature.rect[0], p_offset),
calc_sum(nodes[0]->feature.rect[1],p_offset)); calc_sum(nodes[4]->feature.rect[0], p_offset),
weight = _mm256_set_ps(nodes[7]->feature.rect[1].weight, nodes[6]->feature.rect[1].weight, nodes[5]->feature.rect[1].weight, nodes[4]->feature.rect[1].weight, calc_sum(nodes[3]->feature.rect[0], p_offset),
nodes[3]->feature.rect[1].weight, nodes[2]->feature.rect[1].weight, nodes[1]->feature.rect[1].weight, nodes[0]->feature.rect[1].weight); calc_sum(nodes[2]->feature.rect[0], p_offset),
calc_sum(nodes[1]->feature.rect[0], p_offset),
sum = _mm256_add_ps(sum, _mm256_mul_ps(offset,weight)); calc_sum(nodes[0]->feature.rect[0], p_offset));
if( nodes[0]->feature.rect[2].p0 ) __m256 weight = _mm256_set_ps(nodes[7]->feature.rect[0].weight,
tmp[0] = calc_sum(nodes[0]->feature.rect[2],p_offset) * nodes[0]->feature.rect[2].weight; nodes[6]->feature.rect[0].weight,
if( nodes[1]->feature.rect[2].p0 ) nodes[5]->feature.rect[0].weight,
tmp[1] = calc_sum(nodes[1]->feature.rect[2],p_offset) * nodes[1]->feature.rect[2].weight; nodes[4]->feature.rect[0].weight,
if( nodes[2]->feature.rect[2].p0 ) nodes[3]->feature.rect[0].weight,
tmp[2] = calc_sum(nodes[2]->feature.rect[2],p_offset) * nodes[2]->feature.rect[2].weight; nodes[2]->feature.rect[0].weight,
if( nodes[3]->feature.rect[2].p0 ) nodes[1]->feature.rect[0].weight,
tmp[3] = calc_sum(nodes[3]->feature.rect[2],p_offset) * nodes[3]->feature.rect[2].weight; nodes[0]->feature.rect[0].weight);
if( nodes[4]->feature.rect[2].p0 )
tmp[4] = calc_sum(nodes[4]->feature.rect[2],p_offset) * nodes[4]->feature.rect[2].weight; __m256 sum = _mm256_mul_ps(offset, weight);
if( nodes[5]->feature.rect[2].p0 )
tmp[5] = calc_sum(nodes[5]->feature.rect[2],p_offset) * nodes[5]->feature.rect[2].weight; offset = _mm256_set_ps(calc_sum(nodes[7]->feature.rect[1], p_offset),
if( nodes[6]->feature.rect[2].p0 ) calc_sum(nodes[6]->feature.rect[1], p_offset),
tmp[6] = calc_sum(nodes[6]->feature.rect[2],p_offset) * nodes[6]->feature.rect[2].weight; calc_sum(nodes[5]->feature.rect[1], p_offset),
if( nodes[7]->feature.rect[2].p0 ) calc_sum(nodes[4]->feature.rect[1], p_offset),
tmp[7] = calc_sum(nodes[7]->feature.rect[2],p_offset) * nodes[7]->feature.rect[2].weight; calc_sum(nodes[3]->feature.rect[1], p_offset),
calc_sum(nodes[2]->feature.rect[1], p_offset),
sum = _mm256_add_ps(sum, _mm256_load_ps(tmp)); calc_sum(nodes[1]->feature.rect[1], p_offset),
calc_sum(nodes[0]->feature.rect[1], p_offset));
__m256 alpha0 = _mm256_set_ps(classifiers[7]->alpha[0],classifiers[6]->alpha[0],classifiers[5]->alpha[0],classifiers[4]->alpha[0],classifiers[3]->alpha[0],
classifiers[2]->alpha[0],classifiers[1]->alpha[0],classifiers[0]->alpha[0]); weight = _mm256_set_ps(nodes[7]->feature.rect[1].weight,
__m256 alpha1 = _mm256_set_ps(classifiers[7]->alpha[1],classifiers[6]->alpha[1],classifiers[5]->alpha[1],classifiers[4]->alpha[1],classifiers[3]->alpha[1], nodes[6]->feature.rect[1].weight,
classifiers[2]->alpha[1],classifiers[1]->alpha[1],classifiers[0]->alpha[1]); nodes[5]->feature.rect[1].weight,
nodes[4]->feature.rect[1].weight,
__m256 outBuf = _mm256_blendv_ps(alpha0, alpha1, _mm256_cmp_ps(t, sum, _CMP_LE_OQ )); nodes[3]->feature.rect[1].weight,
outBuf = _mm256_hadd_ps(outBuf, outBuf); nodes[2]->feature.rect[1].weight,
outBuf = _mm256_hadd_ps(outBuf, outBuf); nodes[1]->feature.rect[1].weight,
_mm256_store_ps(buf, outBuf); nodes[0]->feature.rect[1].weight);
stage_sum+=(buf[0]+buf[4]);//(buf[0]+buf[1]+buf[2]+buf[3]+buf[4]+buf[5]+buf[6]+buf[7]);
} sum = _mm256_add_ps(sum, _mm256_mul_ps(offset, weight));
if( nodes[0]->feature.rect[2].p0 )
tmp[0] = calc_sum(nodes[0]->feature.rect[2],p_offset) * nodes[0]->feature.rect[2].weight;
if( nodes[1]->feature.rect[2].p0 )
tmp[1] = calc_sum(nodes[1]->feature.rect[2],p_offset) * nodes[1]->feature.rect[2].weight;
if( nodes[2]->feature.rect[2].p0 )
tmp[2] = calc_sum(nodes[2]->feature.rect[2],p_offset) * nodes[2]->feature.rect[2].weight;
if( nodes[3]->feature.rect[2].p0 )
tmp[3] = calc_sum(nodes[3]->feature.rect[2],p_offset) * nodes[3]->feature.rect[2].weight;
if( nodes[4]->feature.rect[2].p0 )
tmp[4] = calc_sum(nodes[4]->feature.rect[2],p_offset) * nodes[4]->feature.rect[2].weight;
if( nodes[5]->feature.rect[2].p0 )
tmp[5] = calc_sum(nodes[5]->feature.rect[2],p_offset) * nodes[5]->feature.rect[2].weight;
if( nodes[6]->feature.rect[2].p0 )
tmp[6] = calc_sum(nodes[6]->feature.rect[2],p_offset) * nodes[6]->feature.rect[2].weight;
if( nodes[7]->feature.rect[2].p0 )
tmp[7] = calc_sum(nodes[7]->feature.rect[2],p_offset) * nodes[7]->feature.rect[2].weight;
sum = _mm256_add_ps(sum, _mm256_load_ps(tmp));
__m256 alpha0 = _mm256_set_ps(classifiers[7]->alpha[0],
classifiers[6]->alpha[0],
classifiers[5]->alpha[0],
classifiers[4]->alpha[0],
classifiers[3]->alpha[0],
classifiers[2]->alpha[0],
classifiers[1]->alpha[0],
classifiers[0]->alpha[0]);
__m256 alpha1 = _mm256_set_ps(classifiers[7]->alpha[1],
classifiers[6]->alpha[1],
classifiers[5]->alpha[1],
classifiers[4]->alpha[1],
classifiers[3]->alpha[1],
classifiers[2]->alpha[1],
classifiers[1]->alpha[1],
classifiers[0]->alpha[1]);
__m256 outBuf = _mm256_blendv_ps(alpha0, alpha1, _mm256_cmp_ps(t, sum, _CMP_LE_OQ ));
outBuf = _mm256_hadd_ps(outBuf, outBuf);
outBuf = _mm256_hadd_ps(outBuf, outBuf);
_mm256_store_ps(buf, outBuf);
stage_sum += (buf[0] + buf[4]);
}
for( ; j < cascade->stage_classifier[i].count; j++ ) for( ; j < cascade->stage_classifier[i].count; j++ )
{ {
CvHidHaarClassifier* classifier = cascade->stage_classifier[i].classifier + j; CvHidHaarClassifier* classifier = cascade->stage_classifier[i].classifier + j;
CvHidHaarTreeNode* node = classifier->node; CvHidHaarTreeNode* node = classifier->node;
double t = node->threshold*variance_norm_factor; double t = node->threshold*variance_norm_factor;
double sum = calc_sum(node->feature.rect[0],p_offset) * node->feature.rect[0].weight; double sum = calc_sum(node->feature.rect[0],p_offset) * node->feature.rect[0].weight;
sum += calc_sum(node->feature.rect[1],p_offset) * node->feature.rect[1].weight; sum += calc_sum(node->feature.rect[1],p_offset) * node->feature.rect[1].weight;
if( node->feature.rect[2].p0 ) if( node->feature.rect[2].p0 )
sum += calc_sum(node->feature.rect[2],p_offset) * node->feature.rect[2].weight; sum += calc_sum(node->feature.rect[2],p_offset) * node->feature.rect[2].weight;
stage_sum += classifier->alpha[sum >= t]; stage_sum += classifier->alpha[sum >= t];
}
} }
if( stage_sum < cascade->stage_classifier[i].threshold )
return -i;
} }
if( stage_sum < cascade->stage_classifier[i].threshold )
return -i;
} }
else }
#endif else
#if defined CV_HAAR_USE_SSE && CV_HAAR_USE_SSE && (!defined CV_HAAR_USE_AVX || !CV_HAAR_USE_AVX) //old SSE optimization #elif defined CV_HAAR_USE_SSE //old SSE optimization
if(haveSSE2) if(haveSSE2)
{
for( i = start_stage; i < cascade->count; i++ )
{ {
for( i = start_stage; i < cascade->count; i++ ) __m128d vstage_sum = _mm_setzero_pd();
if( cascade->stage_classifier[i].two_rects )
{ {
__m128d vstage_sum = _mm_setzero_pd(); for( j = 0; j < cascade->stage_classifier[i].count; j++ )
if( cascade->stage_classifier[i].two_rects )
{ {
for( j = 0; j < cascade->stage_classifier[i].count; j++ ) CvHidHaarClassifier* classifier = cascade->stage_classifier[i].classifier + j;
{ CvHidHaarTreeNode* node = classifier->node;
CvHidHaarClassifier* classifier = cascade->stage_classifier[i].classifier + j;
CvHidHaarTreeNode* node = classifier->node; // ayasin - NHM perf optim. Avoid use of costly flaky jcc
__m128d t = _mm_set_sd(node->threshold*variance_norm_factor);
// ayasin - NHM perf optim. Avoid use of costly flaky jcc __m128d a = _mm_set_sd(classifier->alpha[0]);
__m128d t = _mm_set_sd(node->threshold*variance_norm_factor); __m128d b = _mm_set_sd(classifier->alpha[1]);
__m128d a = _mm_set_sd(classifier->alpha[0]); __m128d sum = _mm_set_sd(calc_sum(node->feature.rect[0],p_offset) * node->feature.rect[0].weight +
__m128d b = _mm_set_sd(classifier->alpha[1]); calc_sum(node->feature.rect[1],p_offset) * node->feature.rect[1].weight);
__m128d sum = _mm_set_sd(calc_sum(node->feature.rect[0],p_offset) * node->feature.rect[0].weight + t = _mm_cmpgt_sd(t, sum);
calc_sum(node->feature.rect[1],p_offset) * node->feature.rect[1].weight); vstage_sum = _mm_add_sd(vstage_sum, _mm_blendv_pd(b, a, t));
t = _mm_cmpgt_sd(t, sum);
vstage_sum = _mm_add_sd(vstage_sum, _mm_blendv_pd(b, a, t));
}
} }
else }
else
{
for( j = 0; j < cascade->stage_classifier[i].count; j++ )
{ {
for( j = 0; j < cascade->stage_classifier[i].count; j++ ) CvHidHaarClassifier* classifier = cascade->stage_classifier[i].classifier + j;
{ CvHidHaarTreeNode* node = classifier->node;
CvHidHaarClassifier* classifier = cascade->stage_classifier[i].classifier + j; // ayasin - NHM perf optim. Avoid use of costly flaky jcc
CvHidHaarTreeNode* node = classifier->node; __m128d t = _mm_set_sd(node->threshold*variance_norm_factor);
// ayasin - NHM perf optim. Avoid use of costly flaky jcc __m128d a = _mm_set_sd(classifier->alpha[0]);
__m128d t = _mm_set_sd(node->threshold*variance_norm_factor); __m128d b = _mm_set_sd(classifier->alpha[1]);
__m128d a = _mm_set_sd(classifier->alpha[0]); double _sum = calc_sum(node->feature.rect[0],p_offset) * node->feature.rect[0].weight;
__m128d b = _mm_set_sd(classifier->alpha[1]); _sum += calc_sum(node->feature.rect[1],p_offset) * node->feature.rect[1].weight;
double _sum = calc_sum(node->feature.rect[0],p_offset) * node->feature.rect[0].weight; if( node->feature.rect[2].p0 )
_sum += calc_sum(node->feature.rect[1],p_offset) * node->feature.rect[1].weight; _sum += calc_sum(node->feature.rect[2],p_offset) * node->feature.rect[2].weight;
if( node->feature.rect[2].p0 ) __m128d sum = _mm_set_sd(_sum);
_sum += calc_sum(node->feature.rect[2],p_offset) * node->feature.rect[2].weight;
__m128d sum = _mm_set_sd(_sum); t = _mm_cmpgt_sd(t, sum);
vstage_sum = _mm_add_sd(vstage_sum, _mm_blendv_pd(b, a, t));
t = _mm_cmpgt_sd(t, sum);
vstage_sum = _mm_add_sd(vstage_sum, _mm_blendv_pd(b, a, t));
}
} }
__m128d i_threshold = _mm_set1_pd(cascade->stage_classifier[i].threshold);
if( _mm_comilt_sd(vstage_sum, i_threshold) )
return -i;
} }
__m128d i_threshold = _mm_set1_pd(cascade->stage_classifier[i].threshold);
if( _mm_comilt_sd(vstage_sum, i_threshold) )
return -i;
} }
else }
#endif else
#endif // AVX or SSE
{
for( i = start_stage; i < cascade->count; i++ )
{ {
for( i = start_stage; i < cascade->count; i++ ) stage_sum = 0.0;
if( cascade->stage_classifier[i].two_rects )
{ {
stage_sum = 0.0; for( j = 0; j < cascade->stage_classifier[i].count; j++ )
if( cascade->stage_classifier[i].two_rects )
{ {
for( j = 0; j < cascade->stage_classifier[i].count; j++ ) CvHidHaarClassifier* classifier = cascade->stage_classifier[i].classifier + j;
{ CvHidHaarTreeNode* node = classifier->node;
CvHidHaarClassifier* classifier = cascade->stage_classifier[i].classifier + j; double t = node->threshold*variance_norm_factor;
CvHidHaarTreeNode* node = classifier->node; double sum = calc_sum(node->feature.rect[0],p_offset) * node->feature.rect[0].weight;
double t = node->threshold*variance_norm_factor; sum += calc_sum(node->feature.rect[1],p_offset) * node->feature.rect[1].weight;
double sum = calc_sum(node->feature.rect[0],p_offset) * node->feature.rect[0].weight; stage_sum += classifier->alpha[sum >= t];
sum += calc_sum(node->feature.rect[1],p_offset) * node->feature.rect[1].weight;
stage_sum += classifier->alpha[sum >= t];
}
} }
else }
else
{
for( j = 0; j < cascade->stage_classifier[i].count; j++ )
{ {
for( j = 0; j < cascade->stage_classifier[i].count; j++ ) CvHidHaarClassifier* classifier = cascade->stage_classifier[i].classifier + j;
{ CvHidHaarTreeNode* node = classifier->node;
CvHidHaarClassifier* classifier = cascade->stage_classifier[i].classifier + j; double t = node->threshold*variance_norm_factor;
CvHidHaarTreeNode* node = classifier->node; double sum = calc_sum(node->feature.rect[0],p_offset) * node->feature.rect[0].weight;
double t = node->threshold*variance_norm_factor; sum += calc_sum(node->feature.rect[1],p_offset) * node->feature.rect[1].weight;
double sum = calc_sum(node->feature.rect[0],p_offset) * node->feature.rect[0].weight; if( node->feature.rect[2].p0 )
sum += calc_sum(node->feature.rect[1],p_offset) * node->feature.rect[1].weight; sum += calc_sum(node->feature.rect[2],p_offset) * node->feature.rect[2].weight;
if( node->feature.rect[2].p0 ) stage_sum += classifier->alpha[sum >= t];
sum += calc_sum(node->feature.rect[2],p_offset) * node->feature.rect[2].weight;
stage_sum += classifier->alpha[sum >= t];
}
} }
if( stage_sum < cascade->stage_classifier[i].threshold )
return -i;
} }
if( stage_sum < cascade->stage_classifier[i].threshold )
return -i;
} }
}
} }
else else
{ {
for( i = start_stage; i < cascade->count; i++ ) for( i = start_stage; i < cascade->count; i++ )
{ {
stage_sum = 0.0; stage_sum = 0.0;
int k = 0; int k = 0;
#ifdef CV_HAAR_USE_AVX
#ifdef CV_HAAR_USE_AVX
if(haveAVX) if(haveAVX)
{ {
for( ; k < cascade->stage_classifier[i].count-8; k+=8 ) for( ; k < cascade->stage_classifier[i].count - 8; k += 8 )
{ {
stage_sum += icvEvalHidHaarClassifierAVX( stage_sum += icvEvalHidHaarClassifierAVX(
cascade->stage_classifier[i].classifier+k, cascade->stage_classifier[i].classifier + k,
variance_norm_factor, p_offset ); variance_norm_factor, p_offset );
} }
} }
#endif #endif
for(; k < cascade->stage_classifier[i].count; k++ ) for(; k < cascade->stage_classifier[i].count; k++ )
{ {
stage_sum += icvEvalHidHaarClassifier( stage_sum += icvEvalHidHaarClassifier(
cascade->stage_classifier[i].classifier + k, cascade->stage_classifier[i].classifier + k,
variance_norm_factor, p_offset ); variance_norm_factor, p_offset );
} }
if( stage_sum < cascade->stage_classifier[i].threshold ) if( stage_sum < cascade->stage_classifier[i].threshold )
return -i; return -i;
} }
} }
//_mm256_zeroupper();
return 1; return 1;
} }
@ -1186,7 +1299,7 @@ struct HaarDetectObjects_ScaleImage_Invoker
Size ssz(sum1.cols - 1 - winSize0.width, y2 - y1); Size ssz(sum1.cols - 1 - winSize0.width, y2 - y1);
int x, y, ystep = factor > 2 ? 1 : 2; int x, y, ystep = factor > 2 ? 1 : 2;
#ifdef HAVE_IPP #ifdef HAVE_IPP
if( cascade->hid_cascade->ipp_stages ) if( cascade->hid_cascade->ipp_stages )
{ {
IppiRect iequRect = {equRect.x, equRect.y, equRect.width, equRect.height}; IppiRect iequRect = {equRect.x, equRect.y, equRect.width, equRect.height};
@ -1241,7 +1354,7 @@ struct HaarDetectObjects_ScaleImage_Invoker
} }
} }
else else
#endif #endif // IPP
for( y = y1; y < y2; y += ystep ) for( y = y1; y < y2; y += ystep )
for( x = 0; x < ssz.width; x += ystep ) for( x = 0; x < ssz.width; x += ystep )
{ {
@ -1880,18 +1993,18 @@ cvReleaseHaarClassifierCascade( CvHaarClassifierCascade** _cascade )
#define ICV_HAAR_SIZE_NAME "size" #define ICV_HAAR_SIZE_NAME "size"
#define ICV_HAAR_STAGES_NAME "stages" #define ICV_HAAR_STAGES_NAME "stages"
#define ICV_HAAR_TREES_NAME "trees" #define ICV_HAAR_TREES_NAME "trees"
#define ICV_HAAR_FEATURE_NAME "feature" #define ICV_HAAR_FEATURE_NAME "feature"
#define ICV_HAAR_RECTS_NAME "rects" #define ICV_HAAR_RECTS_NAME "rects"
#define ICV_HAAR_TILTED_NAME "tilted" #define ICV_HAAR_TILTED_NAME "tilted"
#define ICV_HAAR_THRESHOLD_NAME "threshold" #define ICV_HAAR_THRESHOLD_NAME "threshold"
#define ICV_HAAR_LEFT_NODE_NAME "left_node" #define ICV_HAAR_LEFT_NODE_NAME "left_node"
#define ICV_HAAR_LEFT_VAL_NAME "left_val" #define ICV_HAAR_LEFT_VAL_NAME "left_val"
#define ICV_HAAR_RIGHT_NODE_NAME "right_node" #define ICV_HAAR_RIGHT_NODE_NAME "right_node"
#define ICV_HAAR_RIGHT_VAL_NAME "right_val" #define ICV_HAAR_RIGHT_VAL_NAME "right_val"
#define ICV_HAAR_STAGE_THRESHOLD_NAME "stage_threshold" #define ICV_HAAR_STAGE_THRESHOLD_NAME "stage_threshold"
#define ICV_HAAR_PARENT_NAME "parent" #define ICV_HAAR_PARENT_NAME "parent"
#define ICV_HAAR_NEXT_NAME "next" #define ICV_HAAR_NEXT_NAME "next"
static int static int
icvIsHaarClassifier( const void* struct_ptr ) icvIsHaarClassifier( const void* struct_ptr )
@ -2418,45 +2531,4 @@ CvType haar_type( CV_TYPE_NAME_HAAR, icvIsHaarClassifier,
icvReadHaarClassifier, icvWriteHaarClassifier, icvReadHaarClassifier, icvWriteHaarClassifier,
icvCloneHaarClassifier ); icvCloneHaarClassifier );
#if 0
namespace cv
{
HaarClassifierCascade::HaarClassifierCascade() {}
HaarClassifierCascade::HaarClassifierCascade(const String& filename)
{ load(filename); }
bool HaarClassifierCascade::load(const String& filename)
{
cascade = Ptr<CvHaarClassifierCascade>((CvHaarClassifierCascade*)cvLoad(filename.c_str(), 0, 0, 0));
return (CvHaarClassifierCascade*)cascade != 0;
}
void HaarClassifierCascade::detectMultiScale( const Mat& image,
Vector<Rect>& objects, double scaleFactor,
int minNeighbors, int flags,
Size minSize )
{
MemStorage storage(cvCreateMemStorage(0));
CvMat _image = image;
CvSeq* _objects = cvHaarDetectObjects( &_image, cascade, storage, scaleFactor,
minNeighbors, flags, minSize );
Seq<Rect>(_objects).copyTo(objects);
}
int HaarClassifierCascade::runAt(Point pt, int startStage, int) const
{
return cvRunHaarClassifierCascade(cascade, pt, startStage);
}
void HaarClassifierCascade::setImages( const Mat& sum, const Mat& sqsum,
const Mat& tilted, double scale )
{
CvMat _sum = sum, _sqsum = sqsum, _tilted = tilted;
cvSetImagesForHaarClassifierCascade( cascade, &_sum, &_sqsum, &_tilted, scale );
}
}
#endif
/* End of file. */ /* End of file. */

2
samples/cpp/pca.cpp
Unescape View File

@ -176,7 +176,7 @@ int main(int argc, char** argv)
// display until user presses q // display until user presses q
imshow(winName, reconstruction); imshow(winName, reconstruction);
char key = 0; int key = 0;
while(key != 'q') while(key != 'q')
key = waitKey(); key = waitKey();

4
samples/cpp/simpleflow_demo.cpp
Unescape View File

@ -86,7 +86,7 @@ static void run(int argc, char** argv) {
Mat flow; Mat flow;
float start = getTickCount(); float start = (float)getTickCount();
calcOpticalFlowSF(frame1, frame2, calcOpticalFlowSF(frame1, frame2,
flow, flow,
3, 2, 4, 4.1, 25.5, 18, 55.0, 25.5, 0.35, 18, 55.0, 25.5, 10); 3, 2, 4, 4.1, 25.5, 18, 55.0, 25.5, 0.35, 18, 55.0, 25.5, 10);
@ -156,7 +156,7 @@ static float calc_rmse(Mat flow1, Mat flow2) {
} }
} }
} }
return sqrt(sum / (1e-9 + counter)); return (float)sqrt(sum / (1e-9 + counter));
} }
static void eval(int argc, char** argv) { static void eval(int argc, char** argv) {

Write Preview
Loading…
Cancel
Save