diff --git a/CMakeLists.txt b/CMakeLists.txt index d7fbb1027b..441ad70b43 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -715,7 +715,7 @@ if(UNIX) CHECK_INCLUDE_FILE(pthread.h HAVE_PTHREAD) if(ANDROID) set(OPENCV_LINKER_LIBS ${OPENCV_LINKER_LIBS} dl m log) - elseif(${CMAKE_SYSTEM_NAME} MATCHES "FreeBSD|NetBSD|DragonFly|OpenBSD|Haiku") + elseif(CMAKE_SYSTEM_NAME MATCHES "FreeBSD|NetBSD|DragonFly|OpenBSD|Haiku") set(OPENCV_LINKER_LIBS ${OPENCV_LINKER_LIBS} m pthread) elseif(EMSCRIPTEN) # no need to link to system libs with emscripten diff --git a/cmake/OpenCVCompilerOptions.cmake b/cmake/OpenCVCompilerOptions.cmake index 218ad1837b..965dccf708 100644 --- a/cmake/OpenCVCompilerOptions.cmake +++ b/cmake/OpenCVCompilerOptions.cmake @@ -296,11 +296,18 @@ endif() # workaround gcc bug for aligned ld/st # https://github.com/opencv/opencv/issues/13211 if((PPC64LE AND NOT CMAKE_CROSSCOMPILING) OR OPENCV_FORCE_COMPILER_CHECK_VSX_ALIGNED) - ocv_check_runtime_flag("${CPU_BASELINE_FLAGS}" "OPENCV_CHECK_VSX_ALIGNED" "${OpenCV_SOURCE_DIR}/cmake/checks/runtime/cpu_vsx_aligned.cpp") + ocv_check_runtime_flag("${CPU_BASELINE_FLAGS}" OPENCV_CHECK_VSX_ALIGNED "${OpenCV_SOURCE_DIR}/cmake/checks/runtime/cpu_vsx_aligned.cpp") if(NOT OPENCV_CHECK_VSX_ALIGNED) add_extra_compiler_option_force(-DCV_COMPILER_VSX_BROKEN_ALIGNED) endif() endif() +# validate inline asm with fixes register number and constraints wa, wd, wf +if(PPC64LE) + ocv_check_compiler_flag(CXX "${CPU_BASELINE_FLAGS}" OPENCV_CHECK_VSX_ASM "${OpenCV_SOURCE_DIR}/cmake/checks/cpu_vsx_asm.cpp") + if(NOT OPENCV_CHECK_VSX_ASM) + add_extra_compiler_option_force(-DCV_COMPILER_VSX_BROKEN_ASM) + endif() +endif() # combine all "extra" options if(NOT OPENCV_SKIP_EXTRA_COMPILER_FLAGS) diff --git a/cmake/OpenCVDetectInferenceEngine.cmake b/cmake/OpenCVDetectInferenceEngine.cmake index 8c17497a25..8656e851f4 100644 --- a/cmake/OpenCVDetectInferenceEngine.cmake +++ b/cmake/OpenCVDetectInferenceEngine.cmake @@ -1,7 +1,6 @@ # The script detects Intel(R) Inference Engine installation # # Cache variables: -# INF_ENGINE_OMP_DIR - directory with OpenMP library to link with (needed by some versions of IE) # INF_ENGINE_RELEASE - a number reflecting IE source interface (linked with OpenVINO release) # # Detect parameters: @@ -11,8 +10,8 @@ # - INF_ENGINE_INCLUDE_DIRS - headers search location # - INF_ENGINE_LIB_DIRS - library search location # 3. OpenVINO location: -# - environment variable INTEL_CVSDK_DIR is set to location of OpenVINO installation dir -# - INF_ENGINE_PLATFORM - part of name of library directory representing its platform (default ubuntu_16.04) +# - environment variable INTEL_OPENVINO_DIR is set to location of OpenVINO installation dir +# - INF_ENGINE_PLATFORM - part of name of library directory representing its platform # # Result: # INF_ENGINE_TARGET - set to name of imported library target representing InferenceEngine @@ -36,11 +35,13 @@ function(add_custom_ie_build _inc _lib _lib_rel _lib_dbg _msg) IMPORTED_IMPLIB_DEBUG "${_lib_dbg}" INTERFACE_INCLUDE_DIRECTORIES "${_inc}" ) - find_library(omp_lib iomp5 PATHS "${INF_ENGINE_OMP_DIR}" NO_DEFAULT_PATH) - if(NOT omp_lib) - message(WARNING "OpenMP for IE have not been found. Set INF_ENGINE_OMP_DIR variable if you experience build errors.") - else() - set_target_properties(inference_engine PROPERTIES IMPORTED_LINK_INTERFACE_LIBRARIES "${omp_lib}") + if(NOT INF_ENGINE_RELEASE VERSION_GREATER "2018050000") + find_library(INF_ENGINE_OMP_LIBRARY iomp5 PATHS "${INF_ENGINE_OMP_DIR}" NO_DEFAULT_PATH) + if(NOT INF_ENGINE_OMP_LIBRARY) + message(WARNING "OpenMP for IE have not been found. Set INF_ENGINE_OMP_DIR variable if you experience build errors.") + else() + set_target_properties(inference_engine PROPERTIES IMPORTED_LINK_INTERFACE_LIBRARIES "${INF_ENGINE_OMP_LIBRARY}") + endif() endif() set(INF_ENGINE_VERSION "Unknown" CACHE STRING "") set(INF_ENGINE_TARGET inference_engine PARENT_SCOPE) @@ -64,9 +65,17 @@ if(NOT INF_ENGINE_TARGET AND INF_ENGINE_LIB_DIRS AND INF_ENGINE_INCLUDE_DIRS) add_custom_ie_build("${ie_custom_inc}" "${ie_custom_lib}" "${ie_custom_lib_rel}" "${ie_custom_lib_dbg}" "INF_ENGINE_{INCLUDE,LIB}_DIRS") endif() -set(_loc "$ENV{INTEL_CVSDK_DIR}") +set(_loc "$ENV{INTEL_OPENVINO_DIR}") +if(NOT _loc AND DEFINED ENV{INTEL_CVSDK_DIR}) + set(_loc "$ENV{INTEL_CVSDK_DIR}") # OpenVINO 2018.x +endif() if(NOT INF_ENGINE_TARGET AND _loc) - set(INF_ENGINE_PLATFORM "ubuntu_16.04" CACHE STRING "InferenceEngine platform (library dir)") + if(NOT INF_ENGINE_RELEASE VERSION_GREATER "2018050000") + set(INF_ENGINE_PLATFORM_DEFAULT "ubuntu_16.04") + else() + set(INF_ENGINE_PLATFORM_DEFAULT "") + endif() + set(INF_ENGINE_PLATFORM "${INF_ENGINE_PLATFORM_DEFAULT}" CACHE STRING "InferenceEngine platform (library dir)") find_path(ie_custom_env_inc "inference_engine.hpp" PATHS "${_loc}/deployment_tools/inference_engine/include" NO_DEFAULT_PATH) find_library(ie_custom_env_lib "inference_engine" PATHS "${_loc}/deployment_tools/inference_engine/lib/${INF_ENGINE_PLATFORM}/intel64" NO_DEFAULT_PATH) find_library(ie_custom_env_lib_rel "inference_engine" PATHS "${_loc}/deployment_tools/inference_engine/lib/intel64/Release" NO_DEFAULT_PATH) diff --git a/cmake/OpenCVUtils.cmake b/cmake/OpenCVUtils.cmake index 974cc3ac06..856d09461a 100644 --- a/cmake/OpenCVUtils.cmake +++ b/cmake/OpenCVUtils.cmake @@ -822,6 +822,11 @@ function(ocv_output_status msg) message(STATUS "${msg}") string(REPLACE "\\" "\\\\" msg "${msg}") string(REPLACE "\"" "\\\"" msg "${msg}") + string(REGEX REPLACE "^\n+|\n+$" "" msg "${msg}") + if(msg MATCHES "\n") + message(WARNING "String to be inserted to version_string.inc has an unexpected line break: '${msg}'") + string(REPLACE "\n" "\\n" msg "${msg}") + endif() set(OPENCV_BUILD_INFO_STR "${OPENCV_BUILD_INFO_STR}\"${msg}\\n\"\n" CACHE INTERNAL "") endfunction() diff --git a/cmake/checks/cpu_vsx_asm.cpp b/cmake/checks/cpu_vsx_asm.cpp new file mode 100644 index 0000000000..bb4c25507e --- /dev/null +++ b/cmake/checks/cpu_vsx_asm.cpp @@ -0,0 +1,21 @@ +#if defined(__VSX__) + #if defined(__PPC64__) && defined(__LITTLE_ENDIAN__) + #include + #else + #error "OpenCV only supports little-endian mode" + #endif +#else + #error "VSX is not supported" +#endif + +/* + * xlc and wide versions of clang don't support %x in the inline asm template which fixes register number + * when using any of the register constraints wa, wd, wf +*/ +int main() +{ + __vector float vf; + __vector signed int vi; + __asm__ __volatile__ ("xvcvsxwsp %x0,%x1" : "=wf" (vf) : "wa" (vi)); + return 0; +} \ No newline at end of file diff --git a/cmake/checks/runtime/cpu_vsx_aligned.cpp b/cmake/checks/runtime/cpu_vsx_aligned.cpp index a8daa63189..90dea65881 100644 --- a/cmake/checks/runtime/cpu_vsx_aligned.cpp +++ b/cmake/checks/runtime/cpu_vsx_aligned.cpp @@ -2,6 +2,7 @@ // https://github.com/opencv/opencv/issues/13211 #include +#undef bool #define vsx_ld vec_vsx_ld #define vsx_st vec_vsx_st diff --git a/doc/tutorials/imgproc/anisotropic_image_segmentation/anisotropic_image_segmentation.markdown b/doc/tutorials/imgproc/anisotropic_image_segmentation/anisotropic_image_segmentation.markdown index 16df8eedd2..489cd6bf3a 100755 --- a/doc/tutorials/imgproc/anisotropic_image_segmentation/anisotropic_image_segmentation.markdown +++ b/doc/tutorials/imgproc/anisotropic_image_segmentation/anisotropic_image_segmentation.markdown @@ -1,6 +1,9 @@ Anisotropic image segmentation by a gradient structure tensor {#tutorial_anisotropic_image_segmentation_by_a_gst} ========================== +@prev_tutorial{tutorial_motion_deblur_filter} +@next_tutorial{tutorial_periodic_noise_removing_filter} + Goal ---- @@ -45,28 +48,65 @@ The orientation of an anisotropic image: Coherency: \f[C = \frac{\lambda_1 - \lambda_2}{\lambda_1 + \lambda_2}\f] -The coherency ranges from 0 to 1. For ideal local orientation (\f$\lambda_2\f$ = 0, \f$\lambda_1\f$ > 0) it is one, for an isotropic gray value structure (\f$\lambda_1\f$ = \f$\lambda_2\f$ > 0) it is zero. +The coherency ranges from 0 to 1. For ideal local orientation (\f$\lambda_2\f$ = 0, \f$\lambda_1\f$ > 0) it is one, for an isotropic gray value structure (\f$\lambda_1\f$ = \f$\lambda_2\f$ \> 0) it is zero. Source code ----------- You can find source code in the `samples/cpp/tutorial_code/ImgProc/anisotropic_image_segmentation/anisotropic_image_segmentation.cpp` of the OpenCV source code library. -@include cpp/tutorial_code/ImgProc/anisotropic_image_segmentation/anisotropic_image_segmentation.cpp +@add_toggle_cpp + @include cpp/tutorial_code/ImgProc/anisotropic_image_segmentation/anisotropic_image_segmentation.cpp +@end_toggle + +@add_toggle_python + @include samples/python/tutorial_code/imgProc/anisotropic_image_segmentation/anisotropic_image_segmentation.py +@end_toggle Explanation ----------- An anisotropic image segmentation algorithm consists of a gradient structure tensor calculation, an orientation calculation, a coherency calculation and an orientation and coherency thresholding: -@snippet samples/cpp/tutorial_code/ImgProc/anisotropic_image_segmentation/anisotropic_image_segmentation.cpp main + +@add_toggle_cpp + @snippet samples/cpp/tutorial_code/ImgProc/anisotropic_image_segmentation/anisotropic_image_segmentation.cpp main +@end_toggle + +@add_toggle_python + @snippet samples/python/tutorial_code/imgProc/anisotropic_image_segmentation/anisotropic_image_segmentation.py main +@end_toggle A function calcGST() calculates orientation and coherency by using a gradient structure tensor. An input parameter w defines a window size: -@snippet samples/cpp/tutorial_code/ImgProc/anisotropic_image_segmentation/anisotropic_image_segmentation.cpp calcGST + +@add_toggle_cpp + @snippet samples/cpp/tutorial_code/ImgProc/anisotropic_image_segmentation/anisotropic_image_segmentation.cpp calcGST +@end_toggle + +@add_toggle_python + @snippet samples/python/tutorial_code/imgProc/anisotropic_image_segmentation/anisotropic_image_segmentation.py calcGST +@end_toggle + The below code applies a thresholds LowThr and HighThr to image orientation and a threshold C_Thr to image coherency calculated by the previous function. LowThr and HighThr define orientation range: -@snippet samples/cpp/tutorial_code/ImgProc/anisotropic_image_segmentation/anisotropic_image_segmentation.cpp thresholding + +@add_toggle_cpp + @snippet samples/cpp/tutorial_code/ImgProc/anisotropic_image_segmentation/anisotropic_image_segmentation.cpp thresholding +@end_toggle + +@add_toggle_python + @snippet samples/python/tutorial_code/imgProc/anisotropic_image_segmentation/anisotropic_image_segmentation.py thresholding +@end_toggle + And finally we combine thresholding results: -@snippet samples/cpp/tutorial_code/ImgProc/anisotropic_image_segmentation/anisotropic_image_segmentation.cpp combining + +@add_toggle_cpp + @snippet samples/cpp/tutorial_code/ImgProc/anisotropic_image_segmentation/anisotropic_image_segmentation.cpp combining +@end_toggle + +@add_toggle_python + @snippet samples/python/tutorial_code/imgProc/anisotropic_image_segmentation/anisotropic_image_segmentation.py combining +@end_toggle + Result ------ diff --git a/doc/tutorials/imgproc/motion_deblur_filter/motion_deblur_filter.markdown b/doc/tutorials/imgproc/motion_deblur_filter/motion_deblur_filter.markdown index 2821e413cd..704e0ef275 100755 --- a/doc/tutorials/imgproc/motion_deblur_filter/motion_deblur_filter.markdown +++ b/doc/tutorials/imgproc/motion_deblur_filter/motion_deblur_filter.markdown @@ -1,6 +1,9 @@ Motion Deblur Filter {#tutorial_motion_deblur_filter} ========================== +@prev_tutorial{tutorial_out_of_focus_deblur_filter} +@next_tutorial{tutorial_anisotropic_image_segmentation_by_a_gst} + Goal ---- diff --git a/doc/tutorials/imgproc/out_of_focus_deblur_filter/out_of_focus_deblur_filter.markdown b/doc/tutorials/imgproc/out_of_focus_deblur_filter/out_of_focus_deblur_filter.markdown index 0e1da4efae..800286d9a8 100755 --- a/doc/tutorials/imgproc/out_of_focus_deblur_filter/out_of_focus_deblur_filter.markdown +++ b/doc/tutorials/imgproc/out_of_focus_deblur_filter/out_of_focus_deblur_filter.markdown @@ -2,6 +2,7 @@ Out-of-focus Deblur Filter {#tutorial_out_of_focus_deblur_filter} ========================== @prev_tutorial{tutorial_distance_transform} +@next_tutorial{tutorial_motion_deblur_filter} Goal ---- diff --git a/doc/tutorials/imgproc/periodic_noise_removing_filter/periodic_noise_removing_filter.markdown b/doc/tutorials/imgproc/periodic_noise_removing_filter/periodic_noise_removing_filter.markdown index ca0ffbf02b..3c36a1e9c4 100755 --- a/doc/tutorials/imgproc/periodic_noise_removing_filter/periodic_noise_removing_filter.markdown +++ b/doc/tutorials/imgproc/periodic_noise_removing_filter/periodic_noise_removing_filter.markdown @@ -1,6 +1,8 @@ Periodic Noise Removing Filter {#tutorial_periodic_noise_removing_filter} ========================== +@prev_tutorial{tutorial_anisotropic_image_segmentation_by_a_gst} + Goal ---- diff --git a/modules/calib3d/include/opencv2/calib3d.hpp b/modules/calib3d/include/opencv2/calib3d.hpp index 149484ebc2..b6f3b30696 100644 --- a/modules/calib3d/include/opencv2/calib3d.hpp +++ b/modules/calib3d/include/opencv2/calib3d.hpp @@ -177,8 +177,6 @@ pattern (every view is described by several 3D-2D point correspondences). opencv_source_code/samples/cpp/calibration.cpp - A calibration sample in order to do 3D reconstruction can be found at opencv_source_code/samples/cpp/build3dmodel.cpp - - A calibration sample of an artificially generated camera and chessboard patterns can be - found at opencv_source_code/samples/cpp/calibration_artificial.cpp - A calibration example on stereo calibration can be found at opencv_source_code/samples/cpp/stereo_calib.cpp - A calibration example on stereo matching can be found at diff --git a/modules/core/CMakeLists.txt b/modules/core/CMakeLists.txt index 93ae10ab1b..c11eec4077 100644 --- a/modules/core/CMakeLists.txt +++ b/modules/core/CMakeLists.txt @@ -3,7 +3,7 @@ set(the_description "The Core Functionality") ocv_add_dispatched_file(mathfuncs_core SSE2 AVX AVX2) ocv_add_dispatched_file(stat SSE4_2 AVX2) ocv_add_dispatched_file(arithm SSE2 SSE4_1 AVX2 VSX3) -ocv_add_dispatched_file(convert SSE2 AVX2) +ocv_add_dispatched_file(convert SSE2 AVX2 VSX3) ocv_add_dispatched_file(convert_scale SSE2 AVX2) ocv_add_dispatched_file(count_non_zero SSE2 AVX2) ocv_add_dispatched_file(matmul SSE2 AVX2) diff --git a/modules/core/include/opencv2/core/hal/intrin_vsx.hpp b/modules/core/include/opencv2/core/hal/intrin_vsx.hpp index aa7f6f3d2d..c5ceb11324 100644 --- a/modules/core/include/opencv2/core/hal/intrin_vsx.hpp +++ b/modules/core/include/opencv2/core/hal/intrin_vsx.hpp @@ -11,11 +11,6 @@ #define CV_SIMD128 1 #define CV_SIMD128_64F 1 -/** - * todo: supporting half precision for power9 - * convert instractions xvcvhpsp, xvcvsphp -**/ - namespace cv { @@ -1077,117 +1072,188 @@ inline v_float64x2 v_lut_pairs(const double* tab, const int* idx) { return v_loa inline v_int32x4 v_lut(const int* tab, const v_int32x4& idxvec) { - int CV_DECL_ALIGNED(32) idx[4]; - v_store_aligned(idx, idxvec); + const int idx[4] = { + vec_extract(idxvec.val, 0), + vec_extract(idxvec.val, 1), + vec_extract(idxvec.val, 2), + vec_extract(idxvec.val, 3) + }; return v_int32x4(tab[idx[0]], tab[idx[1]], tab[idx[2]], tab[idx[3]]); } inline v_uint32x4 v_lut(const unsigned* tab, const v_int32x4& idxvec) { - int CV_DECL_ALIGNED(32) idx[4]; - v_store_aligned(idx, idxvec); + const int idx[4] = { + vec_extract(idxvec.val, 0), + vec_extract(idxvec.val, 1), + vec_extract(idxvec.val, 2), + vec_extract(idxvec.val, 3) + }; return v_uint32x4(tab[idx[0]], tab[idx[1]], tab[idx[2]], tab[idx[3]]); } inline v_float32x4 v_lut(const float* tab, const v_int32x4& idxvec) { - int CV_DECL_ALIGNED(32) idx[4]; - v_store_aligned(idx, idxvec); + const int idx[4] = { + vec_extract(idxvec.val, 0), + vec_extract(idxvec.val, 1), + vec_extract(idxvec.val, 2), + vec_extract(idxvec.val, 3) + }; return v_float32x4(tab[idx[0]], tab[idx[1]], tab[idx[2]], tab[idx[3]]); } inline v_float64x2 v_lut(const double* tab, const v_int32x4& idxvec) { - int CV_DECL_ALIGNED(32) idx[4]; - v_store_aligned(idx, idxvec); + const int idx[2] = { + vec_extract(idxvec.val, 0), + vec_extract(idxvec.val, 1) + }; return v_float64x2(tab[idx[0]], tab[idx[1]]); } inline void v_lut_deinterleave(const float* tab, const v_int32x4& idxvec, v_float32x4& x, v_float32x4& y) { - int CV_DECL_ALIGNED(32) idx[4]; - v_store_aligned(idx, idxvec); - x = v_float32x4(tab[idx[0]], tab[idx[1]], tab[idx[2]], tab[idx[3]]); - y = v_float32x4(tab[idx[0]+1], tab[idx[1]+1], tab[idx[2]+1], tab[idx[3]+1]); + vec_float4 xy0 = vec_ld_l8(tab + vec_extract(idxvec.val, 0)); + vec_float4 xy1 = vec_ld_l8(tab + vec_extract(idxvec.val, 1)); + vec_float4 xy2 = vec_ld_l8(tab + vec_extract(idxvec.val, 2)); + vec_float4 xy3 = vec_ld_l8(tab + vec_extract(idxvec.val, 3)); + vec_float4 xy02 = vec_mergeh(xy0, xy2); // x0, x2, y0, y2 + vec_float4 xy13 = vec_mergeh(xy1, xy3); // x1, x3, y1, y3 + x.val = vec_mergeh(xy02, xy13); + y.val = vec_mergel(xy02, xy13); } - inline void v_lut_deinterleave(const double* tab, const v_int32x4& idxvec, v_float64x2& x, v_float64x2& y) { - int CV_DECL_ALIGNED(32) idx[4]; - v_store_aligned(idx, idxvec); - x = v_float64x2(tab[idx[0]], tab[idx[1]]); - y = v_float64x2(tab[idx[0]+1], tab[idx[1]+1]); + vec_double2 xy0 = vsx_ld(vec_extract(idxvec.val, 0), tab); + vec_double2 xy1 = vsx_ld(vec_extract(idxvec.val, 1), tab); + x.val = vec_mergeh(xy0, xy1); + y.val = vec_mergel(xy0, xy1); } inline v_int8x16 v_interleave_pairs(const v_int8x16& vec) { - vec_short8 vec0 = vec_mergeh((vec_short8)vec.val, (vec_short8)vec_mergesql(vec.val, vec.val)); - vec0 = vec_mergeh(vec0, vec_mergesql(vec0, vec0)); - return v_int8x16(vec_mergeh((vec_char16)vec0, (vec_char16)vec_mergesql(vec0, vec0))); + static const vec_uchar16 perm = {0, 2, 1, 3, 4, 6, 5, 7, 8, 10, 9, 11, 12, 14, 13, 15}; + return v_int8x16(vec_perm(vec.val, vec.val, perm)); } -inline v_uint8x16 v_interleave_pairs(const v_uint8x16& vec) { return v_reinterpret_as_u8(v_interleave_pairs(v_reinterpret_as_s8(vec))); } +inline v_uint8x16 v_interleave_pairs(const v_uint8x16& vec) +{ return v_reinterpret_as_u8(v_interleave_pairs(v_reinterpret_as_s8(vec))); } + inline v_int8x16 v_interleave_quads(const v_int8x16& vec) { - vec_char16 vec0 = (vec_char16)vec_mergeh((vec_int4)vec.val, (vec_int4)vec_mergesql(vec.val, vec.val)); - return v_int8x16(vec_mergeh(vec0, vec_mergesql(vec0, vec0))); + static const vec_uchar16 perm = {0, 4, 1, 5, 2, 6, 3, 7, 8, 12, 9, 13, 10, 14, 11, 15}; + return v_int8x16(vec_perm(vec.val, vec.val, perm)); } -inline v_uint8x16 v_interleave_quads(const v_uint8x16& vec) { return v_reinterpret_as_u8(v_interleave_quads(v_reinterpret_as_s8(vec))); } +inline v_uint8x16 v_interleave_quads(const v_uint8x16& vec) +{ return v_reinterpret_as_u8(v_interleave_quads(v_reinterpret_as_s8(vec))); } inline v_int16x8 v_interleave_pairs(const v_int16x8& vec) { - vec_short8 vec0 = (vec_short8)vec_mergeh((vec_int4)vec.val, (vec_int4)vec_mergesql(vec.val, vec.val)); - return v_int16x8(vec_mergeh(vec0, vec_mergesql(vec0, vec0))); + static const vec_uchar16 perm = {0,1, 4,5, 2,3, 6,7, 8,9, 12,13, 10,11, 14,15}; + return v_int16x8(vec_perm(vec.val, vec.val, perm)); } -inline v_uint16x8 v_interleave_pairs(const v_uint16x8& vec) { return v_reinterpret_as_u16(v_interleave_pairs(v_reinterpret_as_s16(vec))); } +inline v_uint16x8 v_interleave_pairs(const v_uint16x8& vec) +{ return v_reinterpret_as_u16(v_interleave_pairs(v_reinterpret_as_s16(vec))); } + inline v_int16x8 v_interleave_quads(const v_int16x8& vec) { - return v_int16x8(vec_mergeh(vec.val, vec_mergesql(vec.val, vec.val))); + static const vec_uchar16 perm = {0,1, 8,9, 2,3, 10,11, 4,5, 12,13, 6,7, 14,15}; + return v_int16x8(vec_perm(vec.val, vec.val, perm)); } -inline v_uint16x8 v_interleave_quads(const v_uint16x8& vec) { return v_reinterpret_as_u16(v_interleave_quads(v_reinterpret_as_s16(vec))); } +inline v_uint16x8 v_interleave_quads(const v_uint16x8& vec) +{ return v_reinterpret_as_u16(v_interleave_quads(v_reinterpret_as_s16(vec))); } inline v_int32x4 v_interleave_pairs(const v_int32x4& vec) { - return v_int32x4(vec_mergeh(vec.val, vec_mergesql(vec.val, vec.val))); + static const vec_uchar16 perm = {0,1,2,3, 8,9,10,11, 4,5,6,7, 12,13,14,15}; + return v_int32x4(vec_perm(vec.val, vec.val, perm)); } -inline v_uint32x4 v_interleave_pairs(const v_uint32x4& vec) { return v_reinterpret_as_u32(v_interleave_pairs(v_reinterpret_as_s32(vec))); } -inline v_float32x4 v_interleave_pairs(const v_float32x4& vec) { return v_reinterpret_as_f32(v_interleave_pairs(v_reinterpret_as_s32(vec))); } +inline v_uint32x4 v_interleave_pairs(const v_uint32x4& vec) +{ return v_reinterpret_as_u32(v_interleave_pairs(v_reinterpret_as_s32(vec))); } +inline v_float32x4 v_interleave_pairs(const v_float32x4& vec) +{ return v_reinterpret_as_f32(v_interleave_pairs(v_reinterpret_as_s32(vec))); } inline v_int8x16 v_pack_triplets(const v_int8x16& vec) { - schar CV_DECL_ALIGNED(32) val[16]; - v_store_aligned(val, vec); - return v_int8x16(val[0], val[1], val[2], val[4], val[5], val[6], val[8], val[9], val[10], val[12], val[13], val[14], val[15], val[15], val[15], val[15]); + static const vec_uchar16 perm = {0, 1, 2, 4, 5, 6, 8, 9, 10, 12, 13, 14, 15, 15, 15, 15}; + return v_int8x16(vec_perm(vec.val, vec.val, perm)); } -inline v_uint8x16 v_pack_triplets(const v_uint8x16& vec) { return v_reinterpret_as_u8(v_pack_triplets(v_reinterpret_as_s8(vec))); } +inline v_uint8x16 v_pack_triplets(const v_uint8x16& vec) +{ return v_reinterpret_as_u8(v_pack_triplets(v_reinterpret_as_s8(vec))); } inline v_int16x8 v_pack_triplets(const v_int16x8& vec) { - short CV_DECL_ALIGNED(32) val[8]; - v_store_aligned(val, vec); - return v_int16x8(val[0], val[1], val[2], val[4], val[5], val[6], val[7], val[7]); + static const vec_uchar16 perm = {0,1, 2,3, 4,5, 8,9, 10,11, 12,13, 14,15, 14,15}; + return v_int16x8(vec_perm(vec.val, vec.val, perm)); } -inline v_uint16x8 v_pack_triplets(const v_uint16x8& vec) { return v_reinterpret_as_u16(v_pack_triplets(v_reinterpret_as_s16(vec))); } +inline v_uint16x8 v_pack_triplets(const v_uint16x8& vec) +{ return v_reinterpret_as_u16(v_pack_triplets(v_reinterpret_as_s16(vec))); } -inline v_int32x4 v_pack_triplets(const v_int32x4& vec) { return vec; } -inline v_uint32x4 v_pack_triplets(const v_uint32x4& vec) { return vec; } -inline v_float32x4 v_pack_triplets(const v_float32x4& vec) { return vec; } +inline v_int32x4 v_pack_triplets(const v_int32x4& vec) +{ return vec; } +inline v_uint32x4 v_pack_triplets(const v_uint32x4& vec) +{ return vec; } +inline v_float32x4 v_pack_triplets(const v_float32x4& vec) +{ return vec; } /////// FP16 support //////// -// [TODO] implement these 2 using VSX or universal intrinsics (copy from intrin_sse.cpp and adopt) inline v_float32x4 v_load_expand(const float16_t* ptr) { - return v_float32x4((float)ptr[0], (float)ptr[1], (float)ptr[2], (float)ptr[3]); + vec_ushort8 vf16 = vec_ld_l8((const ushort*)ptr); +#if CV_VSX3 && defined(vec_extract_fp_from_shorth) + return v_float32x4(vec_extract_fp_from_shorth(vf16)); +#elif CV_VSX3 && !defined(CV_COMPILER_VSX_BROKEN_ASM) + vec_float4 vf32; + __asm__ __volatile__ ("xvcvhpsp %x0,%x1" : "=wf" (vf32) : "wa" (vec_mergeh(vf16, vf16))); + return v_float32x4(vf32); +#else + const vec_int4 z = vec_int4_z, delta = vec_int4_sp(0x38000000); + const vec_int4 signmask = vec_int4_sp(0x80000000); + const vec_int4 maxexp = vec_int4_sp(0x7c000000); + const vec_float4 deltaf = vec_float4_c(vec_int4_sp(0x38800000)); + + vec_int4 bits = vec_int4_c(vec_mergeh(vec_short8_c(z), vec_short8_c(vf16))); + vec_int4 e = vec_and(bits, maxexp), sign = vec_and(bits, signmask); + vec_int4 t = vec_add(vec_sr(vec_xor(bits, sign), vec_uint4_sp(3)), delta); // ((h & 0x7fff) << 13) + delta + vec_int4 zt = vec_int4_c(vec_sub(vec_float4_c(vec_add(t, vec_int4_sp(1 << 23))), deltaf)); + + t = vec_add(t, vec_and(delta, vec_cmpeq(maxexp, e))); + vec_bint4 zmask = vec_cmpeq(e, z); + vec_int4 ft = vec_sel(t, zt, zmask); + return v_float32x4(vec_float4_c(vec_or(ft, sign))); +#endif } inline void v_pack_store(float16_t* ptr, const v_float32x4& v) { - float CV_DECL_ALIGNED(32) f[4]; - v_store_aligned(f, v); - ptr[0] = float16_t(f[0]); - ptr[1] = float16_t(f[1]); - ptr[2] = float16_t(f[2]); - ptr[3] = float16_t(f[3]); +// fixme: Is there any buitin op or intrinsic that cover "xvcvsphp"? +#if CV_VSX3 && !defined(CV_COMPILER_VSX_BROKEN_ASM) + vec_ushort8 vf16; + __asm__ __volatile__ ("xvcvsphp %x0,%x1" : "=wa" (vf16) : "wf" (v.val)); + vec_st_l8(vec_mergesqe(vf16, vf16), ptr); +#else + const vec_int4 signmask = vec_int4_sp(0x80000000); + const vec_int4 rval = vec_int4_sp(0x3f000000); + + vec_int4 t = vec_int4_c(v.val); + vec_int4 sign = vec_sra(vec_and(t, signmask), vec_uint4_sp(16)); + t = vec_and(vec_nor(signmask, signmask), t); + + vec_bint4 finitemask = vec_cmpgt(vec_int4_sp(0x47800000), t); + vec_bint4 isnan = vec_cmpgt(t, vec_int4_sp(0x7f800000)); + vec_int4 naninf = vec_sel(vec_int4_sp(0x7c00), vec_int4_sp(0x7e00), isnan); + vec_bint4 tinymask = vec_cmpgt(vec_int4_sp(0x38800000), t); + vec_int4 tt = vec_int4_c(vec_add(vec_float4_c(t), vec_float4_c(rval))); + tt = vec_sub(tt, rval); + vec_int4 odd = vec_and(vec_sr(t, vec_uint4_sp(13)), vec_int4_sp(1)); + vec_int4 nt = vec_add(t, vec_int4_sp(0xc8000fff)); + nt = vec_sr(vec_add(nt, odd), vec_uint4_sp(13)); + t = vec_sel(nt, tt, tinymask); + t = vec_sel(naninf, t, finitemask); + t = vec_or(t, sign); + vec_st_l8(vec_packs(t, t), ptr); +#endif } inline void v_cleanup() {} diff --git a/modules/core/include/opencv2/core/vsx_utils.hpp b/modules/core/include/opencv2/core/vsx_utils.hpp index da5b25625c..6e2baeacfc 100644 --- a/modules/core/include/opencv2/core/vsx_utils.hpp +++ b/modules/core/include/opencv2/core/vsx_utils.hpp @@ -291,6 +291,8 @@ VSX_IMPL_1RG(vec_udword2, wi, vec_float4, wf, xvcvspuxds, vec_ctulo) * * So we're not able to use inline asm and only use built-in functions that CLANG supports * and use __builtin_convertvector if clang missng any of vector conversions built-in functions + * + * todo: clang asm template bug is fixed, need to reconsider the current workarounds. */ // convert vector helper diff --git a/modules/core/src/lda.cpp b/modules/core/src/lda.cpp index fb87ff8789..4f67db200d 100644 --- a/modules/core/src/lda.cpp +++ b/modules/core/src/lda.cpp @@ -322,6 +322,8 @@ private: // Fortran subroutine in EISPACK. // Initialize + const int max_iters_count = 1000 * this->n; + int nn = this->n; int n1 = nn - 1; int low = 0; @@ -487,7 +489,9 @@ private: } } - iter = iter + 1; // (Could check iteration count here.) + iter = iter + 1; + if (iter > max_iters_count) + CV_Error(Error::StsNoConv, "Algorithm doesn't converge (complex eigen values?)"); // Look for two consecutive small sub-diagonal elements int m = n1 - 2; diff --git a/modules/core/src/matmul.simd.hpp b/modules/core/src/matmul.simd.hpp index 760bf39e0f..ef54bb037c 100644 --- a/modules/core/src/matmul.simd.hpp +++ b/modules/core/src/matmul.simd.hpp @@ -1451,115 +1451,82 @@ transform_( const T* src, T* dst, const WT* m, int len, int scn, int dcn ) } } -#if CV_SIMD128 && !defined(__aarch64__) -static inline void -load3x3Matrix(const float* m, v_float32x4& m0, v_float32x4& m1, v_float32x4& m2, v_float32x4& m3) -{ - m0 = v_float32x4(m[0], m[4], m[8], 0); - m1 = v_float32x4(m[1], m[5], m[9], 0); - m2 = v_float32x4(m[2], m[6], m[10], 0); - m3 = v_float32x4(m[3], m[7], m[11], 0); -} -#endif - -#if CV_SIMD128 -static inline v_int16x8 -v_matmulvec(const v_int16x8 &v0, const v_int16x8 &m0, const v_int16x8 &m1, const v_int16x8 &m2, const v_int32x4 &m3, const int BITS) -{ - // v0 : 0 b0 g0 r0 b1 g1 r1 ? - v_int32x4 t0 = v_dotprod(v0, m0); // a0 b0 a1 b1 - v_int32x4 t1 = v_dotprod(v0, m1); // c0 d0 c1 d1 - v_int32x4 t2 = v_dotprod(v0, m2); // e0 f0 e1 f1 - v_int32x4 t3 = v_setzero_s32(); - v_int32x4 s0, s1, s2, s3; - v_transpose4x4(t0, t1, t2, t3, s0, s1, s2, s3); - s0 = s0 + s1 + m3; // B0 G0 R0 ? - s2 = s2 + s3 + m3; // B1 G1 R1 ? - - s0 = s0 >> BITS; - s2 = s2 >> BITS; - - v_int16x8 result = v_pack(s0, v_setzero_s32()); // B0 G0 R0 0 0 0 0 0 - result = v_reinterpret_as_s16(v_reinterpret_as_s64(result) << 16); // 0 B0 G0 R0 0 0 0 0 - result = result | v_pack(v_setzero_s32(), s2); // 0 B0 G0 R0 B1 G1 R1 0 - return result; -} -#endif - static void transform_8u( const uchar* src, uchar* dst, const float* m, int len, int scn, int dcn ) { -#if CV_SIMD128 +#if CV_SIMD const int BITS = 10, SCALE = 1 << BITS; const float MAX_M = (float)(1 << (15 - BITS)); - if( hasSIMD128() && scn == 3 && dcn == 3 && - std::abs(m[0]) < MAX_M && std::abs(m[1]) < MAX_M && std::abs(m[2]) < MAX_M && std::abs(m[3]) < MAX_M*256 && - std::abs(m[4]) < MAX_M && std::abs(m[5]) < MAX_M && std::abs(m[6]) < MAX_M && std::abs(m[7]) < MAX_M*256 && - std::abs(m[8]) < MAX_M && std::abs(m[9]) < MAX_M && std::abs(m[10]) < MAX_M && std::abs(m[11]) < MAX_M*256 ) + if( scn == 3 && dcn == 3 && + std::abs(m[0]) < MAX_M && std::abs(m[1]) < MAX_M && std::abs(m[ 2]) < MAX_M*256 && std::abs(m[ 3]) < MAX_M*256 && + std::abs(m[4]) < MAX_M && std::abs(m[5]) < MAX_M && std::abs(m[ 6]) < MAX_M*256 && std::abs(m[ 7]) < MAX_M*256 && + std::abs(m[8]) < MAX_M && std::abs(m[9]) < MAX_M && std::abs(m[10]) < MAX_M*256 && std::abs(m[11]) < MAX_M*256 ) { const int nChannels = 3; - const int cWidth = v_int16x8::nlanes; - // faster fixed-point transformation - short m00 = saturate_cast(m[0]*SCALE), m01 = saturate_cast(m[1]*SCALE), - m02 = saturate_cast(m[2]*SCALE), m10 = saturate_cast(m[4]*SCALE), - m11 = saturate_cast(m[5]*SCALE), m12 = saturate_cast(m[6]*SCALE), - m20 = saturate_cast(m[8]*SCALE), m21 = saturate_cast(m[9]*SCALE), - m22 = saturate_cast(m[10]*SCALE); - int m03 = saturate_cast((m[3]+0.5f)*SCALE), m13 = saturate_cast((m[7]+0.5f)*SCALE ), - m23 = saturate_cast((m[11]+0.5f)*SCALE); - v_int16x8 m0 = v_int16x8(0, m00, m01, m02, m00, m01, m02, 0); - v_int16x8 m1 = v_int16x8(0, m10, m11, m12, m10, m11, m12, 0); - v_int16x8 m2 = v_int16x8(0, m20, m21, m22, m20, m21, m22, 0); - v_int32x4 m3 = v_int32x4(m03, m13, m23, 0); + union { + short s[6]; + int p[3]; + } m16; + m16.s[0] = saturate_cast(m[0] * SCALE); m16.s[1] = saturate_cast(m[1] * SCALE); + m16.s[2] = saturate_cast(m[4] * SCALE); m16.s[3] = saturate_cast(m[5] * SCALE); + m16.s[4] = saturate_cast(m[8] * SCALE); m16.s[5] = saturate_cast(m[9] * SCALE); + int m32[] = {saturate_cast(m[ 2] * SCALE), saturate_cast(m[ 3] * SCALE), + saturate_cast(m[ 6] * SCALE), saturate_cast(m[ 7] * SCALE), + saturate_cast(m[10] * SCALE), saturate_cast(m[11] * SCALE)}; + v_int16 m01 = v_reinterpret_as_s16(vx_setall_s32(m16.p[0])); + v_int32 m2 = vx_setall_s32(m32[0]); + v_int32 m3 = vx_setall_s32(m32[1]); + v_int16 m45 = v_reinterpret_as_s16(vx_setall_s32(m16.p[1])); + v_int32 m6 = vx_setall_s32(m32[2]); + v_int32 m7 = vx_setall_s32(m32[3]); + v_int16 m89 = v_reinterpret_as_s16(vx_setall_s32(m16.p[2])); + v_int32 m10 = vx_setall_s32(m32[4]); + v_int32 m11 = vx_setall_s32(m32[5]); int x = 0; - - for (; x <= (len - cWidth) * nChannels; x += cWidth * nChannels) + for (; x <= (len - v_uint8::nlanes) * nChannels; x += v_uint8::nlanes * nChannels) { - // load 8 pixels - v_int16x8 v0 = v_reinterpret_as_s16(v_load_expand(src + x)); - v_int16x8 v1 = v_reinterpret_as_s16(v_load_expand(src + x + cWidth)); - v_int16x8 v2 = v_reinterpret_as_s16(v_load_expand(src + x + cWidth * 2)); - v_int16x8 v3; + v_uint8 b, g, r; + v_load_deinterleave(src + x, b, g, r); + v_uint8 bgl, bgh; + v_zip(b, g, bgl, bgh); + v_uint16 rl, rh; + v_expand(r, rl, rh); - // rotate and pack - v3 = v_rotate_right<1>(v2); // 0 b6 g6 r6 b7 g7 r7 0 - v2 = v_rotate_left <5>(v2, v1); // 0 b4 g4 r4 b5 g5 r5 0 - v1 = v_rotate_left <3>(v1, v0); // 0 b2 g2 r2 b3 g3 r3 0 - v0 = v_rotate_left <1>(v0); // 0 b0 g0 r0 b1 g1 r1 0 - - // multiply with matrix and normalize - v0 = v_matmulvec(v0, m0, m1, m2, m3, BITS); // 0 B0 G0 R0 B1 G1 R1 0 - v1 = v_matmulvec(v1, m0, m1, m2, m3, BITS); // 0 B2 G2 R2 B3 G3 R3 0 - v2 = v_matmulvec(v2, m0, m1, m2, m3, BITS); // 0 B4 G4 R4 B5 G5 R5 0 - v3 = v_matmulvec(v3, m0, m1, m2, m3, BITS); // 0 B6 G6 R6 B7 G7 R7 0 - - // narrow down as uint8x16 - v_uint8x16 z0 = v_pack_u(v0, v_setzero_s16()); // 0 B0 G0 R0 B1 G1 R1 0 0 0 0 0 0 0 0 0 - v_uint8x16 z1 = v_pack_u(v1, v_setzero_s16()); // 0 B2 G2 R2 B3 G3 R3 0 0 0 0 0 0 0 0 0 - v_uint8x16 z2 = v_pack_u(v2, v_setzero_s16()); // 0 B4 G4 R4 B5 G5 R5 0 0 0 0 0 0 0 0 0 - v_uint8x16 z3 = v_pack_u(v3, v_setzero_s16()); // 0 B6 G6 R6 B7 G7 R7 0 0 0 0 0 0 0 0 0 - - // rotate and pack - z0 = v_reinterpret_as_u8(v_reinterpret_as_u64(z0) >> 8) | v_reinterpret_as_u8(v_reinterpret_as_u64(z1) << 40); // B0 G0 R0 B1 G1 R1 B2 G2 0 0 0 0 0 0 0 0 - z1 = v_reinterpret_as_u8(v_reinterpret_as_u64(z1) >> 24) | v_reinterpret_as_u8(v_reinterpret_as_u64(z2) << 24); // R2 B3 G3 R3 B4 G4 R4 B5 0 0 0 0 0 0 0 0 - z2 = v_reinterpret_as_u8(v_reinterpret_as_u64(z2) >> 40) | v_reinterpret_as_u8(v_reinterpret_as_u64(z3) << 8); // G5 R6 B6 G6 R6 B7 G7 R7 0 0 0 0 0 0 0 0 - - // store on memory - v_store_low(dst + x, z0); - v_store_low(dst + x + cWidth, z1); - v_store_low(dst + x + cWidth * 2, z2); + v_int16 dbl, dbh, dgl, dgh, drl, drh; + v_uint16 p0, p2; + v_int32 p1, p3; + v_expand(bgl, p0, p2); + v_expand(v_reinterpret_as_s16(rl), p1, p3); + dbl = v_rshr_pack(v_dotprod(v_reinterpret_as_s16(p0), m01) + p1 * m2 + m3, + v_dotprod(v_reinterpret_as_s16(p2), m01) + p3 * m2 + m3); + dgl = v_rshr_pack(v_dotprod(v_reinterpret_as_s16(p0), m45) + p1 * m6 + m7, + v_dotprod(v_reinterpret_as_s16(p2), m45) + p3 * m6 + m7); + drl = v_rshr_pack(v_dotprod(v_reinterpret_as_s16(p0), m89) + p1 * m10 + m11, + v_dotprod(v_reinterpret_as_s16(p2), m89) + p3 * m10 + m11); + v_expand(bgh, p0, p2); + v_expand(v_reinterpret_as_s16(rh), p1, p3); + dbh = v_rshr_pack(v_dotprod(v_reinterpret_as_s16(p0), m01) + p1 * m2 + m3, + v_dotprod(v_reinterpret_as_s16(p2), m01) + p3 * m2 + m3); + dgh = v_rshr_pack(v_dotprod(v_reinterpret_as_s16(p0), m45) + p1 * m6 + m7, + v_dotprod(v_reinterpret_as_s16(p2), m45) + p3 * m6 + m7); + drh = v_rshr_pack(v_dotprod(v_reinterpret_as_s16(p0), m89) + p1 * m10 + m11, + v_dotprod(v_reinterpret_as_s16(p2), m89) + p3 * m10 + m11); + v_store_interleave(dst + x, v_pack_u(dbl, dbh), v_pack_u(dgl, dgh), v_pack_u(drl, drh)); } - + m32[1] = saturate_cast((m[3] + 0.5f)*SCALE); + m32[3] = saturate_cast((m[7] + 0.5f)*SCALE); + m32[5] = saturate_cast((m[11] + 0.5f)*SCALE); for( ; x < len * nChannels; x += nChannels ) { int v0 = src[x], v1 = src[x+1], v2 = src[x+2]; - uchar t0 = saturate_cast((m00*v0 + m01*v1 + m02*v2 + m03)>>BITS); - uchar t1 = saturate_cast((m10*v0 + m11*v1 + m12*v2 + m13)>>BITS); - uchar t2 = saturate_cast((m20*v0 + m21*v1 + m22*v2 + m23)>>BITS); + uchar t0 = saturate_cast((m16.s[0] * v0 + m16.s[1] * v1 + m32[0] * v2 + m32[1]) >> BITS); + uchar t1 = saturate_cast((m16.s[2] * v0 + m16.s[3] * v1 + m32[2] * v2 + m32[3]) >> BITS); + uchar t2 = saturate_cast((m16.s[4] * v0 + m16.s[5] * v1 + m32[4] * v2 + m32[5]) >> BITS); dst[x] = t0; dst[x+1] = t1; dst[x+2] = t2; } + vx_cleanup(); return; } #endif @@ -1570,64 +1537,65 @@ transform_8u( const uchar* src, uchar* dst, const float* m, int len, int scn, in static void transform_16u( const ushort* src, ushort* dst, const float* m, int len, int scn, int dcn ) { -#if CV_SIMD128 && !defined(__aarch64__) - if( hasSIMD128() && scn == 3 && dcn == 3 ) +#if CV_SIMD && !defined(__aarch64__) + if( scn == 3 && dcn == 3 ) { - const int nChannels = 3; - const int cWidth = v_float32x4::nlanes; - v_int16x8 delta = v_int16x8(0, -32768, -32768, -32768, -32768, -32768, -32768, 0); - v_float32x4 m0, m1, m2, m3; - load3x3Matrix(m, m0, m1, m2, m3); - m3 -= v_float32x4(32768.f, 32768.f, 32768.f, 0.f); - int x = 0; - for( ; x <= (len - cWidth) * nChannels; x += cWidth * nChannels ) +#if CV_SIMD_WIDTH > 16 + v_float32 m0 = vx_setall_f32(m[ 0]); + v_float32 m1 = vx_setall_f32(m[ 1]); + v_float32 m2 = vx_setall_f32(m[ 2]); + v_float32 m3 = vx_setall_f32(m[ 3] - 32768.f); + v_float32 m4 = vx_setall_f32(m[ 4]); + v_float32 m5 = vx_setall_f32(m[ 5]); + v_float32 m6 = vx_setall_f32(m[ 6]); + v_float32 m7 = vx_setall_f32(m[ 7] - 32768.f); + v_float32 m8 = vx_setall_f32(m[ 8]); + v_float32 m9 = vx_setall_f32(m[ 9]); + v_float32 m10 = vx_setall_f32(m[10]); + v_float32 m11 = vx_setall_f32(m[11] - 32768.f); + v_int16 delta = vx_setall_s16(-32768); + for (; x <= (len - v_uint16::nlanes)*3; x += v_uint16::nlanes*3) { - // load 4 pixels - v_uint16x8 v0_16 = v_load(src + x); // b0 g0 r0 b1 g1 r1 b2 g2 - v_uint16x8 v2_16 = v_load_low(src + x + cWidth * 2); // r2 b3 g3 r3 ? ? ? ? + v_uint16 b, g, r; + v_load_deinterleave(src + x, b, g, r); + v_uint32 bl, bh, gl, gh, rl, rh; + v_expand(b, bl, bh); + v_expand(g, gl, gh); + v_expand(r, rl, rh); - // expand to 4 vectors - v_uint32x4 v0_32, v1_32, v2_32, v3_32, dummy_32; - v_expand(v_rotate_right<3>(v0_16), v1_32, dummy_32); // b1 g1 r1 - v_expand(v_rotate_right<1>(v2_16), v3_32, dummy_32); // b3 g3 r3 - v_expand(v_rotate_right<6>(v0_16, v2_16), v2_32, dummy_32); // b2 g2 r2 - v_expand(v0_16, v0_32, dummy_32); // b0 g0 r0 - - // convert to float32x4 - v_float32x4 x0 = v_cvt_f32(v_reinterpret_as_s32(v0_32)); // b0 g0 r0 - v_float32x4 x1 = v_cvt_f32(v_reinterpret_as_s32(v1_32)); // b1 g1 r1 - v_float32x4 x2 = v_cvt_f32(v_reinterpret_as_s32(v2_32)); // b2 g2 r2 - v_float32x4 x3 = v_cvt_f32(v_reinterpret_as_s32(v3_32)); // b3 g3 r3 - - // multiply and convert back to int32x4 - v_int32x4 y0, y1, y2, y3; - y0 = v_round(v_matmuladd(x0, m0, m1, m2, m3)); // B0 G0 R0 - y1 = v_round(v_matmuladd(x1, m0, m1, m2, m3)); // B1 G1 R1 - y2 = v_round(v_matmuladd(x2, m0, m1, m2, m3)); // B2 G2 R2 - y3 = v_round(v_matmuladd(x3, m0, m1, m2, m3)); // B3 G3 R3 - - // narrow down to int16x8 - v_int16x8 v0 = v_add_wrap(v_pack(v_rotate_left<1>(y0), y1), delta); // 0 B0 G0 R0 B1 G1 R1 0 - v_int16x8 v2 = v_add_wrap(v_pack(v_rotate_left<1>(y2), y3), delta); // 0 B2 G2 R2 B3 G3 R3 0 - - // rotate and pack - v0 = v_rotate_right<1>(v0) | v_rotate_left<5>(v2); // B0 G0 R0 B1 G1 R1 B2 G2 - v2 = v_rotate_right<3>(v2); // R2 B3 G3 R3 0 0 0 0 - - // store 4 pixels - v_store(dst + x, v_reinterpret_as_u16(v0)); - v_store_low(dst + x + cWidth * 2, v_reinterpret_as_u16(v2)); + v_int16 db, dg, dr; + db = v_add_wrap(v_pack(v_round(v_muladd(v_cvt_f32(v_reinterpret_as_s32(bl)), m0, v_muladd(v_cvt_f32(v_reinterpret_as_s32(gl)), m1, v_muladd(v_cvt_f32(v_reinterpret_as_s32(rl)), m2, m3)))), + v_round(v_muladd(v_cvt_f32(v_reinterpret_as_s32(bh)), m0, v_muladd(v_cvt_f32(v_reinterpret_as_s32(gh)), m1, v_muladd(v_cvt_f32(v_reinterpret_as_s32(rh)), m2, m3))))), delta); + dg = v_add_wrap(v_pack(v_round(v_muladd(v_cvt_f32(v_reinterpret_as_s32(bl)), m4, v_muladd(v_cvt_f32(v_reinterpret_as_s32(gl)), m5, v_muladd(v_cvt_f32(v_reinterpret_as_s32(rl)), m6, m7)))), + v_round(v_muladd(v_cvt_f32(v_reinterpret_as_s32(bh)), m4, v_muladd(v_cvt_f32(v_reinterpret_as_s32(gh)), m5, v_muladd(v_cvt_f32(v_reinterpret_as_s32(rh)), m6, m7))))), delta); + dr = v_add_wrap(v_pack(v_round(v_muladd(v_cvt_f32(v_reinterpret_as_s32(bl)), m8, v_muladd(v_cvt_f32(v_reinterpret_as_s32(gl)), m9, v_muladd(v_cvt_f32(v_reinterpret_as_s32(rl)), m10, m11)))), + v_round(v_muladd(v_cvt_f32(v_reinterpret_as_s32(bh)), m8, v_muladd(v_cvt_f32(v_reinterpret_as_s32(gh)), m9, v_muladd(v_cvt_f32(v_reinterpret_as_s32(rh)), m10, m11))))), delta); + v_store_interleave(dst + x, v_reinterpret_as_u16(db), v_reinterpret_as_u16(dg), v_reinterpret_as_u16(dr)); } - - for( ; x < len * nChannels; x += nChannels ) +#endif + v_float32x4 _m0l(m[0], m[4], m[ 8], 0.f); + v_float32x4 _m1l(m[1], m[5], m[ 9], 0.f); + v_float32x4 _m2l(m[2], m[6], m[10], 0.f); + v_float32x4 _m3l(m[3] - 32768.f, m[7] - 32768.f, m[11] - 32768.f, 0.f); + v_float32x4 _m0h = v_rotate_left<1>(_m0l); + v_float32x4 _m1h = v_rotate_left<1>(_m1l); + v_float32x4 _m2h = v_rotate_left<1>(_m2l); + v_float32x4 _m3h = v_rotate_left<1>(_m3l); + v_int16x8 _delta(0, -32768, -32768, -32768, -32768, -32768, -32768, 0); + for( ; x <= len*3 - v_uint16x8::nlanes; x += 3*v_uint16x8::nlanes/4 ) + v_store(dst + x, v_rotate_right<1>(v_reinterpret_as_u16(v_add_wrap(v_pack( + v_round(v_matmuladd(v_cvt_f32(v_reinterpret_as_s32(v_load_expand(src + x ))), _m0h, _m1h, _m2h, _m3h)), + v_round(v_matmuladd(v_cvt_f32(v_reinterpret_as_s32(v_load_expand(src + x + 3))), _m0l, _m1l, _m2l, _m3l))), _delta)))); + for( ; x < len * 3; x += 3 ) { float v0 = src[x], v1 = src[x + 1], v2 = src[x + 2]; - ushort t0 = saturate_cast(m[0] * v0 + m[1] * v1 + m[2] * v2 + m[3]); - ushort t1 = saturate_cast(m[4] * v0 + m[5] * v1 + m[6] * v2 + m[7]); + ushort t0 = saturate_cast(m[0] * v0 + m[1] * v1 + m[ 2] * v2 + m[ 3]); + ushort t1 = saturate_cast(m[4] * v0 + m[5] * v1 + m[ 6] * v2 + m[ 7]); ushort t2 = saturate_cast(m[8] * v0 + m[9] * v1 + m[10] * v2 + m[11]); dst[x] = t0; dst[x + 1] = t1; dst[x + 2] = t2; } + vx_cleanup(); return; } #endif @@ -1638,52 +1606,68 @@ transform_16u( const ushort* src, ushort* dst, const float* m, int len, int scn, static void transform_32f( const float* src, float* dst, const float* m, int len, int scn, int dcn ) { -#if CV_SIMD128 && !defined(__aarch64__) - if( hasSIMD128() ) +#if CV_SIMD && !defined(__aarch64__) + int x = 0; + if( scn == 3 && dcn == 3 ) { - int x = 0; - if( scn == 3 && dcn == 3 ) + int idx[v_float32::nlanes/2]; + for( int i = 0; i < v_float32::nlanes/4; i++ ) { - const int cWidth = 3; - v_float32x4 m0, m1, m2, m3; - load3x3Matrix(m, m0, m1, m2, m3); - - for( ; x < (len - 1)*cWidth; x += cWidth ) - { - v_float32x4 x0 = v_load(src + x); - v_float32x4 y0 = v_matmuladd(x0, m0, m1, m2, m3); - v_store_low(dst + x, y0); - dst[x + 2] = v_combine_high(y0, y0).get0(); - } - - for( ; x < len*cWidth; x += cWidth ) - { - float v0 = src[x], v1 = src[x+1], v2 = src[x+2]; - float t0 = saturate_cast(m[0]*v0 + m[1]*v1 + m[2]*v2 + m[3]); - float t1 = saturate_cast(m[4]*v0 + m[5]*v1 + m[6]*v2 + m[7]); - float t2 = saturate_cast(m[8]*v0 + m[9]*v1 + m[10]*v2 + m[11]); - dst[x] = t0; dst[x+1] = t1; dst[x+2] = t2; - } - return; + idx[i] = 3*i; + idx[i + v_float32::nlanes/4] = 0; } - - if( scn == 4 && dcn == 4 ) + float _m[] = { m[0], m[4], m[ 8], 0.f, + m[1], m[5], m[ 9], 0.f, + m[2], m[6], m[10], 0.f, + m[3], m[7], m[11], 0.f }; + v_float32 m0 = vx_lut_quads(_m , idx + v_float32::nlanes/4); + v_float32 m1 = vx_lut_quads(_m + 4, idx + v_float32::nlanes/4); + v_float32 m2 = vx_lut_quads(_m + 8, idx + v_float32::nlanes/4); + v_float32 m3 = vx_lut_quads(_m + 12, idx + v_float32::nlanes/4); + for( ; x <= len*3 - v_float32::nlanes; x += 3*v_float32::nlanes/4 ) + v_store(dst + x, v_pack_triplets(v_matmuladd(vx_lut_quads(src + x, idx), m0, m1, m2, m3))); + for( ; x < len*3; x += 3 ) { - const int cWidth = 4; - v_float32x4 m0 = v_float32x4(m[0], m[5], m[10], m[15]); - v_float32x4 m1 = v_float32x4(m[1], m[6], m[11], m[16]); - v_float32x4 m2 = v_float32x4(m[2], m[7], m[12], m[17]); - v_float32x4 m3 = v_float32x4(m[3], m[8], m[13], m[18]); - v_float32x4 m4 = v_float32x4(m[4], m[9], m[14], m[19]); - - for( ; x < len*cWidth; x += cWidth ) - { - v_float32x4 x0 = v_load(src + x); - v_float32x4 y0 = v_matmul(x0, m0, m1, m2, m3) + m4; - v_store(dst + x, y0); - } - return; + float v0 = src[x], v1 = src[x+1], v2 = src[x+2]; + float t0 = saturate_cast(m[0]*v0 + m[1]*v1 + m[ 2]*v2 + m[ 3]); + float t1 = saturate_cast(m[4]*v0 + m[5]*v1 + m[ 6]*v2 + m[ 7]); + float t2 = saturate_cast(m[8]*v0 + m[9]*v1 + m[10]*v2 + m[11]); + dst[x] = t0; dst[x+1] = t1; dst[x+2] = t2; } + vx_cleanup(); + return; + } + + if( scn == 4 && dcn == 4 ) + { +#if CV_SIMD_WIDTH > 16 + int idx[v_float32::nlanes/4]; + for( int i = 0; i < v_float32::nlanes/4; i++ ) + idx[i] = 0; + float _m[] = { m[4], m[9], m[14], m[19] }; + v_float32 m0 = vx_lut_quads(m , idx); + v_float32 m1 = vx_lut_quads(m+ 5, idx); + v_float32 m2 = vx_lut_quads(m+10, idx); + v_float32 m3 = vx_lut_quads(m+15, idx); + v_float32 m4 = vx_lut_quads(_m, idx); + for( ; x <= len*4 - v_float32::nlanes; x += v_float32::nlanes ) + { + v_float32 v_src = vx_load(src + x); + v_store(dst + x, v_reduce_sum4(v_src * m0, v_src * m1, v_src * m2, v_src * m3) + m4); + } +#endif + v_float32x4 _m0 = v_load(m ); + v_float32x4 _m1 = v_load(m + 5); + v_float32x4 _m2 = v_load(m + 10); + v_float32x4 _m3 = v_load(m + 15); + v_float32x4 _m4(m[4], m[9], m[14], m[19]); + for( ; x < len*4; x += v_float32x4::nlanes ) + { + v_float32x4 v_src = v_load(src + x); + v_store(dst + x, v_reduce_sum4(v_src * _m0, v_src * _m1, v_src * _m2, v_src * _m3) + _m4); + } + vx_cleanup(); + return; } #endif diff --git a/modules/core/test/test_eigen.cpp b/modules/core/test/test_eigen.cpp index b2f09ea48c..6f5d82bf4a 100644 --- a/modules/core/test/test_eigen.cpp +++ b/modules/core/test/test_eigen.cpp @@ -519,4 +519,27 @@ TEST_P(Core_EigenZero, double) } INSTANTIATE_TEST_CASE_P(/**/, Core_EigenZero, testing::Values(2, 3, 5)); +TEST(Core_EigenNonSymmetric, convergence) +{ + Matx33d m( + 0, -1, 0, + 1, 0, 1, + 0, -1, 0); + Mat eigenvalues, eigenvectors; + // eigen values are complex, algorithm doesn't converge + try + { + cv::eigenNonSymmetric(m, eigenvalues, eigenvectors); + std::cout << Mat(eigenvalues.t()) << std::endl; + } + catch (const cv::Exception& e) + { + EXPECT_EQ(Error::StsNoConv, e.code) << e.what(); + } + catch (...) + { + FAIL() << "Unknown exception has been raised"; + } +} + }} // namespace diff --git a/modules/flann/include/opencv2/flann/kmeans_index.h b/modules/flann/include/opencv2/flann/kmeans_index.h index 74bbf400c3..fe91dddd16 100644 --- a/modules/flann/include/opencv2/flann/kmeans_index.h +++ b/modules/flann/include/opencv2/flann/kmeans_index.h @@ -276,17 +276,15 @@ public: public: KMeansDistanceComputer(Distance _distance, const Matrix& _dataset, const int _branching, const int* _indices, const Matrix& _dcenters, const size_t _veclen, - int* _count, int* _belongs_to, std::vector& _radiuses, bool& _converged) + std::vector &_new_centroids, std::vector &_sq_dists) : distance(_distance) , dataset(_dataset) , branching(_branching) , indices(_indices) , dcenters(_dcenters) , veclen(_veclen) - , count(_count) - , belongs_to(_belongs_to) - , radiuses(_radiuses) - , converged(_converged) + , new_centroids(_new_centroids) + , sq_dists(_sq_dists) { } @@ -297,8 +295,8 @@ public: for( int i = begin; inew_sq_dist) { @@ -306,15 +304,8 @@ public: sq_dist = new_sq_dist; } } - if (sq_dist > radiuses[new_centroid]) { - radiuses[new_centroid] = sq_dist; - } - if (new_centroid != belongs_to[i]) { - CV_XADD(&count[belongs_to[i]], -1); - CV_XADD(&count[new_centroid], 1); - belongs_to[i] = new_centroid; - converged = false; - } + sq_dists[i] = sq_dist; + new_centroids[i] = new_centroid; } } @@ -325,10 +316,8 @@ public: const int* indices; const Matrix& dcenters; const size_t veclen; - int* count; - int* belongs_to; - std::vector& radiuses; - bool& converged; + std::vector &new_centroids; + std::vector &sq_dists; KMeansDistanceComputer& operator=( const KMeansDistanceComputer & ) { return *this; } }; @@ -796,10 +785,27 @@ private: } } + std::vector new_centroids(indices_length); + std::vector sq_dists(indices_length); + // reassign points to clusters - KMeansDistanceComputer invoker(distance_, dataset_, branching, indices, dcenters, veclen_, count, belongs_to, radiuses, converged); + KMeansDistanceComputer invoker(distance_, dataset_, branching, indices, dcenters, veclen_, new_centroids, sq_dists); parallel_for_(cv::Range(0, (int)indices_length), invoker); + for (int i=0; i < (int)indices_length; ++i) { + DistanceType sq_dist(sq_dists[i]); + int new_centroid(new_centroids[i]); + if (sq_dist > radiuses[new_centroid]) { + radiuses[new_centroid] = sq_dist; + } + if (new_centroid != belongs_to[i]) { + count[belongs_to[i]]--; + count[new_centroid]++; + belongs_to[i] = new_centroid; + converged = false; + } + } + for (int i=0; i 1: fn = cv.samples.findFile(sys.argv[1]) print('loading %s ...' % fn) @@ -62,4 +58,10 @@ if __name__ == '__main__': cv.imshow('preview', small) cv.setMouseCallback('preview', onmouse) cv.waitKey() + print('Done') + + +if __name__ == '__main__': + print(__doc__) + main() cv.destroyAllWindows() diff --git a/samples/python/calibrate.py b/samples/python/calibrate.py index e0896ea7ef..2378d8bf1a 100755 --- a/samples/python/calibrate.py +++ b/samples/python/calibrate.py @@ -25,7 +25,7 @@ from common import splitfn # built-in modules import os -if __name__ == '__main__': +def main(): import sys import getopt from glob import glob @@ -126,4 +126,10 @@ if __name__ == '__main__': print('Undistorted image written to: %s' % outfile) cv.imwrite(outfile, dst) + print('Done') + + +if __name__ == '__main__': + print(__doc__) + main() cv.destroyAllWindows() diff --git a/samples/python/camera_calibration_show_extrinsics.py b/samples/python/camera_calibration_show_extrinsics.py index 6304aa7931..610138bc7b 100755 --- a/samples/python/camera_calibration_show_extrinsics.py +++ b/samples/python/camera_calibration_show_extrinsics.py @@ -1,14 +1,14 @@ #!/usr/bin/env python # -*- coding: utf-8 -*- -from mpl_toolkits.mplot3d import Axes3D -import matplotlib.pyplot as plt +# Python 2/3 compatibility +from __future__ import print_function + import numpy as np -from matplotlib import cm -from numpy import linspace -import argparse import cv2 as cv +from numpy import linspace + def inverse_homogeneoux_matrix(M): R = M[0:3, 0:3] T = M[0:3, 3] @@ -119,6 +119,8 @@ def create_board_model(extrinsics, board_width, board_height, square_size, draw_ def draw_camera_boards(ax, camera_matrix, cam_width, cam_height, scale_focal, extrinsics, board_width, board_height, square_size, patternCentric): + from matplotlib import cm + min_values = np.zeros((3,1)) min_values = np.inf max_values = np.zeros((3,1)) @@ -158,6 +160,8 @@ def draw_camera_boards(ax, camera_matrix, cam_width, cam_height, scale_focal, return min_values, max_values def main(): + import argparse + parser = argparse.ArgumentParser(description='Plot camera calibration extrinsics.', formatter_class=argparse.ArgumentDefaultsHelpFormatter) parser.add_argument('--calibration', type=str, default='left_intrinsics.yml', @@ -179,6 +183,9 @@ def main(): camera_matrix = fs.getNode('camera_matrix').mat() extrinsics = fs.getNode('extrinsic_parameters').mat() + import matplotlib.pyplot as plt + from mpl_toolkits.mplot3d import Axes3D + fig = plt.figure() ax = fig.gca(projection='3d') ax.set_aspect("equal") @@ -211,6 +218,10 @@ def main(): ax.set_title('Extrinsic Parameters Visualization') plt.show() + print('Done') -if __name__ == "__main__": + +if __name__ == '__main__': + print(__doc__) main() + cv.destroyAllWindows() diff --git a/samples/python/camshift.py b/samples/python/camshift.py index 58055122c8..101da85b31 100755 --- a/samples/python/camshift.py +++ b/samples/python/camshift.py @@ -119,10 +119,10 @@ class App(object): if __name__ == '__main__': + print(__doc__) import sys try: video_src = sys.argv[1] except: video_src = 0 - print(__doc__) App(video_src).run() diff --git a/samples/python/coherence.py b/samples/python/coherence.py index 59db351d8d..147b33ee5a 100755 --- a/samples/python/coherence.py +++ b/samples/python/coherence.py @@ -46,7 +46,7 @@ def coherence_filter(img, sigma = 11, str_sigma = 11, blend = 0.5, iter_n = 4): return img -if __name__ == '__main__': +def main(): import sys try: fn = sys.argv[1] @@ -82,4 +82,11 @@ if __name__ == '__main__': update() if ch == 27: break + + print('Done') + + +if __name__ == '__main__': + print(__doc__) + main() cv.destroyAllWindows() diff --git a/samples/python/color_histogram.py b/samples/python/color_histogram.py index 3a2e532c7e..0422d7282c 100755 --- a/samples/python/color_histogram.py +++ b/samples/python/color_histogram.py @@ -8,6 +8,9 @@ Keys: ''' +# Python 2/3 compatibility +from __future__ import print_function + import numpy as np import cv2 as cv @@ -17,46 +20,54 @@ import sys # local modules import video +class App(): + + def set_scale(self, val): + self.hist_scale = val + + def run(self): + hsv_map = np.zeros((180, 256, 3), np.uint8) + h, s = np.indices(hsv_map.shape[:2]) + hsv_map[:,:,0] = h + hsv_map[:,:,1] = s + hsv_map[:,:,2] = 255 + hsv_map = cv.cvtColor(hsv_map, cv.COLOR_HSV2BGR) + cv.imshow('hsv_map', hsv_map) + + cv.namedWindow('hist', 0) + self.hist_scale = 10 + + cv.createTrackbar('scale', 'hist', self.hist_scale, 32, self.set_scale) + + try: + fn = sys.argv[1] + except: + fn = 0 + cam = video.create_capture(fn, fallback='synth:bg=baboon.jpg:class=chess:noise=0.05') + + while True: + flag, frame = cam.read() + cv.imshow('camera', frame) + + small = cv.pyrDown(frame) + + hsv = cv.cvtColor(small, cv.COLOR_BGR2HSV) + dark = hsv[...,2] < 32 + hsv[dark] = 0 + h = cv.calcHist([hsv], [0, 1], None, [180, 256], [0, 180, 0, 256]) + + h = np.clip(h*0.005*self.hist_scale, 0, 1) + vis = hsv_map*h[:,:,np.newaxis] / 255.0 + cv.imshow('hist', vis) + + ch = cv.waitKey(1) + if ch == 27: + break + + print('Done') + + if __name__ == '__main__': - - hsv_map = np.zeros((180, 256, 3), np.uint8) - h, s = np.indices(hsv_map.shape[:2]) - hsv_map[:,:,0] = h - hsv_map[:,:,1] = s - hsv_map[:,:,2] = 255 - hsv_map = cv.cvtColor(hsv_map, cv.COLOR_HSV2BGR) - cv.imshow('hsv_map', hsv_map) - - cv.namedWindow('hist', 0) - hist_scale = 10 - - def set_scale(val): - global hist_scale - hist_scale = val - cv.createTrackbar('scale', 'hist', hist_scale, 32, set_scale) - - try: - fn = sys.argv[1] - except: - fn = 0 - cam = video.create_capture(fn, fallback='synth:bg=baboon.jpg:class=chess:noise=0.05') - - while True: - flag, frame = cam.read() - cv.imshow('camera', frame) - - small = cv.pyrDown(frame) - - hsv = cv.cvtColor(small, cv.COLOR_BGR2HSV) - dark = hsv[...,2] < 32 - hsv[dark] = 0 - h = cv.calcHist([hsv], [0, 1], None, [180, 256], [0, 180, 0, 256]) - - h = np.clip(h*0.005*hist_scale, 0, 1) - vis = hsv_map*h[:,:,np.newaxis] / 255.0 - cv.imshow('hist', vis) - - ch = cv.waitKey(1) - if ch == 27: - break + print(__doc__) + App().run() cv.destroyAllWindows() diff --git a/samples/python/contours.py b/samples/python/contours.py index 555c561c7c..285e376a33 100755 --- a/samples/python/contours.py +++ b/samples/python/contours.py @@ -48,9 +48,7 @@ def make_image(): cv.ellipse( img, (dx+273, dy+100), (20,35), 0, 0, 360, white, -1 ) return img -if __name__ == '__main__': - print(__doc__) - +def main(): img = make_image() h, w = img.shape[:2] @@ -67,4 +65,10 @@ if __name__ == '__main__': cv.createTrackbar( "levels+3", "contours", 3, 7, update ) cv.imshow('image', img) cv.waitKey() + print('Done') + + +if __name__ == '__main__': + print(__doc__) + main() cv.destroyAllWindows() diff --git a/samples/python/deconvolution.py b/samples/python/deconvolution.py index 109f46cddb..bf136c522f 100755 --- a/samples/python/deconvolution.py +++ b/samples/python/deconvolution.py @@ -65,8 +65,7 @@ def defocus_kernel(d, sz=65): return kern -if __name__ == '__main__': - print(__doc__) +def main(): import sys, getopt opts, args = getopt.getopt(sys.argv[1:], '', ['circle', 'angle=', 'd=', 'snr=']) opts = dict(opts) @@ -128,3 +127,11 @@ if __name__ == '__main__': if ch == ord(' '): defocus = not defocus update(None) + + print('Done') + + +if __name__ == '__main__': + print(__doc__) + main() + cv.destroyAllWindows() diff --git a/samples/python/dft.py b/samples/python/dft.py index d5a0f03e06..98bc87dc24 100755 --- a/samples/python/dft.py +++ b/samples/python/dft.py @@ -11,8 +11,9 @@ USAGE: # Python 2/3 compatibility from __future__ import print_function -import cv2 as cv import numpy as np +import cv2 as cv + import sys @@ -62,8 +63,8 @@ def shift_dft(src, dst=None): return dst -if __name__ == "__main__": +def main(): if len(sys.argv) > 1: fname = sys.argv[1] else: @@ -110,4 +111,10 @@ if __name__ == "__main__": cv.imshow("magnitude", log_spectrum) cv.waitKey(0) + print('Done') + + +if __name__ == '__main__': + print(__doc__) + main() cv.destroyAllWindows() diff --git a/samples/python/digits.py b/samples/python/digits.py index ea9844e312..f58e9dd987 100755 --- a/samples/python/digits.py +++ b/samples/python/digits.py @@ -27,12 +27,12 @@ Usage: # Python 2/3 compatibility from __future__ import print_function +import numpy as np +import cv2 as cv + # built-in modules from multiprocessing.pool import ThreadPool -import cv2 as cv - -import numpy as np from numpy.linalg import norm # local modules diff --git a/samples/python/digits_adjust.py b/samples/python/digits_adjust.py index 2e50fe8d40..1c041c1d31 100755 --- a/samples/python/digits_adjust.py +++ b/samples/python/digits_adjust.py @@ -23,6 +23,7 @@ if PY3: import numpy as np import cv2 as cv + from multiprocessing.pool import ThreadPool from digits import * diff --git a/samples/python/digits_video.py b/samples/python/digits_video.py index 5cfcb57c04..4d54db9a97 100755 --- a/samples/python/digits_video.py +++ b/samples/python/digits_video.py @@ -96,6 +96,10 @@ def main(): if ch == 27: break + print('Done') + + if __name__ == '__main__': + print(__doc__) main() cv.destroyAllWindows() diff --git a/samples/python/distrans.py b/samples/python/distrans.py index 939ecfdc82..aa423a7af9 100755 --- a/samples/python/distrans.py +++ b/samples/python/distrans.py @@ -19,13 +19,12 @@ import cv2 as cv from common import make_cmap -if __name__ == '__main__': +def main(): import sys try: fn = sys.argv[1] except: fn = 'fruits.jpg' - print(__doc__) fn = cv.samples.findFile(fn) img = cv.imread(fn, cv.IMREAD_GRAYSCALE) @@ -69,4 +68,11 @@ if __name__ == '__main__': update() if need_update: update() + + print('Done') + + +if __name__ == '__main__': + print(__doc__) + main() cv.destroyAllWindows() diff --git a/samples/python/edge.py b/samples/python/edge.py index ae09c3c223..ba04adecfe 100755 --- a/samples/python/edge.py +++ b/samples/python/edge.py @@ -23,9 +23,7 @@ import video import sys -if __name__ == '__main__': - print(__doc__) - +def main(): try: fn = sys.argv[1] except: @@ -52,4 +50,11 @@ if __name__ == '__main__': ch = cv.waitKey(5) if ch == 27: break + + print('Done') + + +if __name__ == '__main__': + print(__doc__) + main() cv.destroyAllWindows() diff --git a/samples/python/facedetect.py b/samples/python/facedetect.py index 73d9341273..1050cc5aff 100755 --- a/samples/python/facedetect.py +++ b/samples/python/facedetect.py @@ -30,9 +30,8 @@ def draw_rects(img, rects, color): for x1, y1, x2, y2 in rects: cv.rectangle(img, (x1, y1), (x2, y2), color, 2) -if __name__ == '__main__': +def main(): import sys, getopt - print(__doc__) args, video_src = getopt.getopt(sys.argv[1:], '', ['cascade=', 'nested-cascade=']) try: @@ -70,4 +69,11 @@ if __name__ == '__main__': if cv.waitKey(5) == 27: break + + print('Done') + + +if __name__ == '__main__': + print(__doc__) + main() cv.destroyAllWindows() diff --git a/samples/python/find_obj.py b/samples/python/find_obj.py index d0c67b085c..2fa9a34e69 100755 --- a/samples/python/find_obj.py +++ b/samples/python/find_obj.py @@ -19,6 +19,7 @@ from __future__ import print_function import numpy as np import cv2 as cv + from common import anorm, getsize FLANN_INDEX_KDTREE = 1 # bug: flann enums are missing @@ -137,9 +138,7 @@ def explore_match(win, img1, img2, kp_pairs, status = None, H = None): return vis -if __name__ == '__main__': - print(__doc__) - +def main(): import sys, getopt opts, args = getopt.getopt(sys.argv[1:], '', ['feature=']) opts = dict(opts) @@ -187,4 +186,11 @@ if __name__ == '__main__': match_and_draw('find_obj') cv.waitKey() + + print('Done') + + +if __name__ == '__main__': + print(__doc__) + main() cv.destroyAllWindows() diff --git a/samples/python/fitline.py b/samples/python/fitline.py index b8d282abb8..6705f39abb 100755 --- a/samples/python/fitline.py +++ b/samples/python/fitline.py @@ -79,9 +79,7 @@ def update(_=None): draw_str(img, (20, 20), cur_func_name) cv.imshow('fit line', img) -if __name__ == '__main__': - print(__doc__) - +def main(): cv.namedWindow('fit line') cv.createTrackbar('noise', 'fit line', 3, 50, update) cv.createTrackbar('point n', 'fit line', 100, 500, update) @@ -96,3 +94,11 @@ if __name__ == '__main__': cur_func_name = dist_func_names.next() if ch == 27: break + + print('Done') + + +if __name__ == '__main__': + print(__doc__) + main() + cv.destroyAllWindows() diff --git a/samples/python/floodfill.py b/samples/python/floodfill.py index 29986c5d84..da4b0095a1 100755 --- a/samples/python/floodfill.py +++ b/samples/python/floodfill.py @@ -20,61 +20,69 @@ from __future__ import print_function import numpy as np import cv2 as cv -if __name__ == '__main__': - import sys - try: - fn = sys.argv[1] - except: - fn = 'fruits.jpg' - print(__doc__) +import sys - img = cv.imread(cv.samples.findFile(fn)) - if img is None: - print('Failed to load image file:', fn) - sys.exit(1) +class App(): - h, w = img.shape[:2] - mask = np.zeros((h+2, w+2), np.uint8) - seed_pt = None - fixed_range = True - connectivity = 4 - - def update(dummy=None): - if seed_pt is None: - cv.imshow('floodfill', img) + def update(self, dummy=None): + if self.seed_pt is None: + cv.imshow('floodfill', self.img) return - flooded = img.copy() - mask[:] = 0 + flooded = self.img.copy() + self.mask[:] = 0 lo = cv.getTrackbarPos('lo', 'floodfill') hi = cv.getTrackbarPos('hi', 'floodfill') - flags = connectivity - if fixed_range: + flags = self.connectivity + if self.fixed_range: flags |= cv.FLOODFILL_FIXED_RANGE - cv.floodFill(flooded, mask, seed_pt, (255, 255, 255), (lo,)*3, (hi,)*3, flags) - cv.circle(flooded, seed_pt, 2, (0, 0, 255), -1) + cv.floodFill(flooded, self.mask, self.seed_pt, (255, 255, 255), (lo,)*3, (hi,)*3, flags) + cv.circle(flooded, self.seed_pt, 2, (0, 0, 255), -1) cv.imshow('floodfill', flooded) - def onmouse(event, x, y, flags, param): - global seed_pt + def onmouse(self, event, x, y, flags, param): if flags & cv.EVENT_FLAG_LBUTTON: - seed_pt = x, y - update() + self.seed_pt = x, y + self.update() - update() - cv.setMouseCallback('floodfill', onmouse) - cv.createTrackbar('lo', 'floodfill', 20, 255, update) - cv.createTrackbar('hi', 'floodfill', 20, 255, update) + def run(self): + try: + fn = sys.argv[1] + except: + fn = 'fruits.jpg' - while True: - ch = cv.waitKey() - if ch == 27: - break - if ch == ord('f'): - fixed_range = not fixed_range - print('using %s range' % ('floating', 'fixed')[fixed_range]) - update() - if ch == ord('c'): - connectivity = 12-connectivity - print('connectivity =', connectivity) - update() + self.img = cv.imread(cv.samples.findFile(fn)) + if self.img is None: + print('Failed to load image file:', fn) + sys.exit(1) + + h, w = self.img.shape[:2] + self.mask = np.zeros((h+2, w+2), np.uint8) + self.seed_pt = None + self.fixed_range = True + self.connectivity = 4 + + self.update() + cv.setMouseCallback('floodfill', self.onmouse) + cv.createTrackbar('lo', 'floodfill', 20, 255, self.update) + cv.createTrackbar('hi', 'floodfill', 20, 255, self.update) + + while True: + ch = cv.waitKey() + if ch == 27: + break + if ch == ord('f'): + self.fixed_range = not self.fixed_range + print('using %s range' % ('floating', 'fixed')[self.fixed_range]) + self.update() + if ch == ord('c'): + self.connectivity = 12-self.connectivity + print('connectivity =', self.connectivity) + self.update() + + print('Done') + + +if __name__ == '__main__': + print(__doc__) + App().run() cv.destroyAllWindows() diff --git a/samples/python/gabor_threads.py b/samples/python/gabor_threads.py index 377fa9ad0b..dd14e6bf43 100755 --- a/samples/python/gabor_threads.py +++ b/samples/python/gabor_threads.py @@ -19,6 +19,7 @@ from __future__ import print_function import numpy as np import cv2 as cv + from multiprocessing.pool import ThreadPool @@ -47,11 +48,10 @@ def process_threaded(img, filters, threadn = 8): np.maximum(accum, fimg, accum) return accum -if __name__ == '__main__': +def main(): import sys from common import Timer - print(__doc__) try: img_fn = sys.argv[1] except: @@ -73,4 +73,10 @@ if __name__ == '__main__': cv.imshow('img', img) cv.imshow('result', res2) cv.waitKey() + print('Done') + + +if __name__ == '__main__': + print(__doc__) + main() cv.destroyAllWindows() diff --git a/samples/python/gaussian_mix.py b/samples/python/gaussian_mix.py index a939928f40..5f2dfcc440 100755 --- a/samples/python/gaussian_mix.py +++ b/samples/python/gaussian_mix.py @@ -9,9 +9,10 @@ if PY3: xrange = range import numpy as np -from numpy import random import cv2 as cv +from numpy import random + def make_gaussians(cluster_n, img_size): points = [] ref_distrs = [] @@ -34,7 +35,7 @@ def draw_gaussain(img, mean, cov, color): cv.ellipse(img, (x, y), (s1, s2), ang, 0, 360, color, 1, cv.LINE_AA) -if __name__ == '__main__': +def main(): cluster_n = 5 img_size = 512 @@ -66,4 +67,11 @@ if __name__ == '__main__': ch = cv.waitKey(0) if ch == 27: break + + print('Done') + + +if __name__ == '__main__': + print(__doc__) + main() cv.destroyAllWindows() diff --git a/samples/python/grabcut.py b/samples/python/grabcut.py index 318e23453f..f63c0cb387 100644 --- a/samples/python/grabcut.py +++ b/samples/python/grabcut.py @@ -32,148 +32,154 @@ from __future__ import print_function import numpy as np import cv2 as cv + import sys -BLUE = [255,0,0] # rectangle color -RED = [0,0,255] # PR BG -GREEN = [0,255,0] # PR FG -BLACK = [0,0,0] # sure BG -WHITE = [255,255,255] # sure FG +class App(): + BLUE = [255,0,0] # rectangle color + RED = [0,0,255] # PR BG + GREEN = [0,255,0] # PR FG + BLACK = [0,0,0] # sure BG + WHITE = [255,255,255] # sure FG -DRAW_BG = {'color' : BLACK, 'val' : 0} -DRAW_FG = {'color' : WHITE, 'val' : 1} -DRAW_PR_FG = {'color' : GREEN, 'val' : 3} -DRAW_PR_BG = {'color' : RED, 'val' : 2} + DRAW_BG = {'color' : BLACK, 'val' : 0} + DRAW_FG = {'color' : WHITE, 'val' : 1} + DRAW_PR_FG = {'color' : GREEN, 'val' : 3} + DRAW_PR_BG = {'color' : RED, 'val' : 2} -# setting up flags -rect = (0,0,1,1) -drawing = False # flag for drawing curves -rectangle = False # flag for drawing rect -rect_over = False # flag to check if rect drawn -rect_or_mask = 100 # flag for selecting rect or mask mode -value = DRAW_FG # drawing initialized to FG -thickness = 3 # brush thickness + # setting up flags + rect = (0,0,1,1) + drawing = False # flag for drawing curves + rectangle = False # flag for drawing rect + rect_over = False # flag to check if rect drawn + rect_or_mask = 100 # flag for selecting rect or mask mode + value = DRAW_FG # drawing initialized to FG + thickness = 3 # brush thickness -def onmouse(event,x,y,flags,param): - global img,img2,drawing,value,mask,rectangle,rect,rect_or_mask,ix,iy,rect_over + def onmouse(self, event, x, y, flags, param): + # Draw Rectangle + if event == cv.EVENT_RBUTTONDOWN: + self.rectangle = True + self.ix, self.iy = x,y - # Draw Rectangle - if event == cv.EVENT_RBUTTONDOWN: - rectangle = True - ix,iy = x,y + elif event == cv.EVENT_MOUSEMOVE: + if self.rectangle == True: + self.img = self.img2.copy() + cv.rectangle(self.img, (self.ix, self.iy), (x, y), self.BLUE, 2) + self.rect = (min(self.ix, x), min(self.iy, y), abs(self.ix - x), abs(self.iy - y)) + self.rect_or_mask = 0 - elif event == cv.EVENT_MOUSEMOVE: - if rectangle == True: - img = img2.copy() - cv.rectangle(img,(ix,iy),(x,y),BLUE,2) - rect = (min(ix,x),min(iy,y),abs(ix-x),abs(iy-y)) - rect_or_mask = 0 + elif event == cv.EVENT_RBUTTONUP: + self.rectangle = False + self.rect_over = True + cv.rectangle(self.img, (self.ix, self.iy), (x, y), self.BLUE, 2) + self.rect = (min(self.ix, x), min(self.iy, y), abs(self.ix - x), abs(self.iy - y)) + self.rect_or_mask = 0 + print(" Now press the key 'n' a few times until no further change \n") - elif event == cv.EVENT_RBUTTONUP: - rectangle = False - rect_over = True - cv.rectangle(img,(ix,iy),(x,y),BLUE,2) - rect = (min(ix,x),min(iy,y),abs(ix-x),abs(iy-y)) - rect_or_mask = 0 - print(" Now press the key 'n' a few times until no further change \n") + # draw touchup curves - # draw touchup curves + if event == cv.EVENT_LBUTTONDOWN: + if self.rect_over == False: + print("first draw rectangle \n") + else: + self.drawing = True + cv.circle(self.img, (x,y), self.thickness, self.value['color'], -1) + cv.circle(self.mask, (x,y), self.thickness, self.value['val'], -1) - if event == cv.EVENT_LBUTTONDOWN: - if rect_over == False: - print("first draw rectangle \n") + elif event == cv.EVENT_MOUSEMOVE: + if self.drawing == True: + cv.circle(self.img, (x, y), self.thickness, self.value['color'], -1) + cv.circle(self.mask, (x, y), self.thickness, self.value['val'], -1) + + elif event == cv.EVENT_LBUTTONUP: + if self.drawing == True: + self.drawing = False + cv.circle(self.img, (x, y), self.thickness, self.value['color'], -1) + cv.circle(self.mask, (x, y), self.thickness, self.value['val'], -1) + + def run(self): + # Loading images + if len(sys.argv) == 2: + filename = sys.argv[1] # for drawing purposes else: - drawing = True - cv.circle(img,(x,y),thickness,value['color'],-1) - cv.circle(mask,(x,y),thickness,value['val'],-1) + print("No input image given, so loading default image, lena.jpg \n") + print("Correct Usage: python grabcut.py \n") + filename = 'lena.jpg' - elif event == cv.EVENT_MOUSEMOVE: - if drawing == True: - cv.circle(img,(x,y),thickness,value['color'],-1) - cv.circle(mask,(x,y),thickness,value['val'],-1) + self.img = cv.imread(cv.samples.findFile(filename)) + self.img2 = self.img.copy() # a copy of original image + self.mask = np.zeros(self.img.shape[:2], dtype = np.uint8) # mask initialized to PR_BG + self.output = np.zeros(self.img.shape, np.uint8) # output image to be shown + + # input and output windows + cv.namedWindow('output') + cv.namedWindow('input') + cv.setMouseCallback('input', self.onmouse) + cv.moveWindow('input', self.img.shape[1]+10,90) + + print(" Instructions: \n") + print(" Draw a rectangle around the object using right mouse button \n") + + while(1): + + cv.imshow('output', self.output) + cv.imshow('input', self.img) + k = cv.waitKey(1) + + # key bindings + if k == 27: # esc to exit + break + elif k == ord('0'): # BG drawing + print(" mark background regions with left mouse button \n") + self.value = self.DRAW_BG + elif k == ord('1'): # FG drawing + print(" mark foreground regions with left mouse button \n") + self.value = self.DRAW_FG + elif k == ord('2'): # PR_BG drawing + self.value = self.DRAW_PR_BG + elif k == ord('3'): # PR_FG drawing + self.value = self.DRAW_PR_FG + elif k == ord('s'): # save image + bar = np.zeros((self.img.shape[0], 5, 3), np.uint8) + res = np.hstack((self.img2, bar, self.img, bar, self.output)) + cv.imwrite('grabcut_output.png', res) + print(" Result saved as image \n") + elif k == ord('r'): # reset everything + print("resetting \n") + self.rect = (0,0,1,1) + self.drawing = False + self.rectangle = False + self.rect_or_mask = 100 + self.rect_over = False + self.value = self.DRAW_FG + self.img = self.img2.copy() + self.mask = np.zeros(self.img.shape[:2], dtype = np.uint8) # mask initialized to PR_BG + self.output = np.zeros(self.img.shape, np.uint8) # output image to be shown + elif k == ord('n'): # segment the image + print(""" For finer touchups, mark foreground and background after pressing keys 0-3 + and again press 'n' \n""") + try: + if (self.rect_or_mask == 0): # grabcut with rect + bgdmodel = np.zeros((1, 65), np.float64) + fgdmodel = np.zeros((1, 65), np.float64) + cv.grabCut(self.img2, self.mask, self.rect, bgdmodel, fgdmodel, 1, cv.GC_INIT_WITH_RECT) + self.rect_or_mask = 1 + elif self.rect_or_mask == 1: # grabcut with mask + bgdmodel = np.zeros((1, 65), np.float64) + fgdmodel = np.zeros((1, 65), np.float64) + cv.grabCut(self.img2, self.mask, self.rect, bgdmodel, fgdmodel, 1, cv.GC_INIT_WITH_MASK) + except: + import traceback + traceback.print_exc() + + mask2 = np.where((self.mask==1) + (self.mask==3), 255, 0).astype('uint8') + self.output = cv.bitwise_and(self.img2, self.img2, mask=mask2) + + print('Done') - elif event == cv.EVENT_LBUTTONUP: - if drawing == True: - drawing = False - cv.circle(img,(x,y),thickness,value['color'],-1) - cv.circle(mask,(x,y),thickness,value['val'],-1) if __name__ == '__main__': - - # print documentation print(__doc__) - - # Loading images - if len(sys.argv) == 2: - filename = sys.argv[1] # for drawing purposes - else: - print("No input image given, so loading default image, lena.jpg \n") - print("Correct Usage: python grabcut.py \n") - filename = 'lena.jpg' - - img = cv.imread(cv.samples.findFile(filename)) - img2 = img.copy() # a copy of original image - mask = np.zeros(img.shape[:2],dtype = np.uint8) # mask initialized to PR_BG - output = np.zeros(img.shape,np.uint8) # output image to be shown - - # input and output windows - cv.namedWindow('output') - cv.namedWindow('input') - cv.setMouseCallback('input',onmouse) - cv.moveWindow('input',img.shape[1]+10,90) - - print(" Instructions: \n") - print(" Draw a rectangle around the object using right mouse button \n") - - while(1): - - cv.imshow('output',output) - cv.imshow('input',img) - k = cv.waitKey(1) - - # key bindings - if k == 27: # esc to exit - break - elif k == ord('0'): # BG drawing - print(" mark background regions with left mouse button \n") - value = DRAW_BG - elif k == ord('1'): # FG drawing - print(" mark foreground regions with left mouse button \n") - value = DRAW_FG - elif k == ord('2'): # PR_BG drawing - value = DRAW_PR_BG - elif k == ord('3'): # PR_FG drawing - value = DRAW_PR_FG - elif k == ord('s'): # save image - bar = np.zeros((img.shape[0],5,3),np.uint8) - res = np.hstack((img2,bar,img,bar,output)) - cv.imwrite('grabcut_output.png',res) - print(" Result saved as image \n") - elif k == ord('r'): # reset everything - print("resetting \n") - rect = (0,0,1,1) - drawing = False - rectangle = False - rect_or_mask = 100 - rect_over = False - value = DRAW_FG - img = img2.copy() - mask = np.zeros(img.shape[:2],dtype = np.uint8) # mask initialized to PR_BG - output = np.zeros(img.shape,np.uint8) # output image to be shown - elif k == ord('n'): # segment the image - print(""" For finer touchups, mark foreground and background after pressing keys 0-3 - and again press 'n' \n""") - if (rect_or_mask == 0): # grabcut with rect - bgdmodel = np.zeros((1,65),np.float64) - fgdmodel = np.zeros((1,65),np.float64) - cv.grabCut(img2,mask,rect,bgdmodel,fgdmodel,1,cv.GC_INIT_WITH_RECT) - rect_or_mask = 1 - elif rect_or_mask == 1: # grabcut with mask - bgdmodel = np.zeros((1,65),np.float64) - fgdmodel = np.zeros((1,65),np.float64) - cv.grabCut(img2,mask,rect,bgdmodel,fgdmodel,1,cv.GC_INIT_WITH_MASK) - - mask2 = np.where((mask==1) + (mask==3),255,0).astype('uint8') - output = cv.bitwise_and(img2,img2,mask=mask2) - + App().run() cv.destroyAllWindows() diff --git a/samples/python/hist.py b/samples/python/hist.py index e085fdc55e..4e73f0bc65 100755 --- a/samples/python/hist.py +++ b/samples/python/hist.py @@ -18,8 +18,8 @@ Abid Rahman 3/14/12 debug Gary Bradski # Python 2/3 compatibility from __future__ import print_function -import cv2 as cv import numpy as np +import cv2 as cv bins = np.arange(256).reshape(256,1) @@ -53,8 +53,7 @@ def hist_lines(im): return y -if __name__ == '__main__': - +def main(): import sys if len(sys.argv)>1: @@ -116,4 +115,11 @@ if __name__ == '__main__': print('ESC') cv.destroyAllWindows() break + + print('Done') + + +if __name__ == '__main__': + print(__doc__) + main() cv.destroyAllWindows() diff --git a/samples/python/houghcircles.py b/samples/python/houghcircles.py index bf0aa43de3..b8d3a1a019 100755 --- a/samples/python/houghcircles.py +++ b/samples/python/houghcircles.py @@ -11,13 +11,12 @@ Usage: # Python 2/3 compatibility from __future__ import print_function -import cv2 as cv import numpy as np +import cv2 as cv + import sys -if __name__ == '__main__': - print(__doc__) - +def main(): try: fn = sys.argv[1] except IndexError: @@ -40,3 +39,10 @@ if __name__ == '__main__': cv.imshow("source", src) cv.waitKey(0) + print('Done') + + +if __name__ == '__main__': + print(__doc__) + main() + cv.destroyAllWindows() diff --git a/samples/python/houghlines.py b/samples/python/houghlines.py index e662854693..7c99cf2ae9 100755 --- a/samples/python/houghlines.py +++ b/samples/python/houghlines.py @@ -13,12 +13,11 @@ from __future__ import print_function import cv2 as cv import numpy as np + import sys import math -if __name__ == '__main__': - print(__doc__) - +def main(): try: fn = sys.argv[1] except IndexError: @@ -52,3 +51,10 @@ if __name__ == '__main__': cv.imshow("source", src) cv.waitKey(0) + print('Done') + + +if __name__ == '__main__': + print(__doc__) + main() + cv.destroyAllWindows() diff --git a/samples/python/inpaint.py b/samples/python/inpaint.py index 3e2fd5635e..53f8e9886f 100755 --- a/samples/python/inpaint.py +++ b/samples/python/inpaint.py @@ -20,17 +20,16 @@ from __future__ import print_function import numpy as np import cv2 as cv + from common import Sketcher -if __name__ == '__main__': +def main(): import sys try: fn = sys.argv[1] except: fn = 'fruits.jpg' - print(__doc__) - img = cv.imread(cv.samples.findFile(fn)) if img is None: print('Failed to load image file:', fn) @@ -51,4 +50,11 @@ if __name__ == '__main__': img_mark[:] = img mark[:] = 0 sketch.show() + + print('Done') + + +if __name__ == '__main__': + print(__doc__) + main() cv.destroyAllWindows() diff --git a/samples/python/kalman.py b/samples/python/kalman.py index 3028f54c76..654e3de3da 100755 --- a/samples/python/kalman.py +++ b/samples/python/kalman.py @@ -18,12 +18,13 @@ PY3 = sys.version_info[0] == 3 if PY3: long = int +import numpy as np import cv2 as cv + from math import cos, sin, sqrt import numpy as np -if __name__ == "__main__": - +def main(): img_height = 500 img_width = 500 kalman = cv.KalmanFilter(2, 1, 0) @@ -93,4 +94,10 @@ if __name__ == "__main__": if code in [27, ord('q'), ord('Q')]: break - cv.destroyWindow("Kalman") + print('Done') + + +if __name__ == '__main__': + print(__doc__) + main() + cv.destroyAllWindows() diff --git a/samples/python/kmeans.py b/samples/python/kmeans.py index 9c67b7ae55..d7fcbe8083 100755 --- a/samples/python/kmeans.py +++ b/samples/python/kmeans.py @@ -18,12 +18,10 @@ import cv2 as cv from gaussian_mix import make_gaussians -if __name__ == '__main__': +def main(): cluster_n = 5 img_size = 512 - print(__doc__) - # generating bright palette colors = np.zeros((1, cluster_n, 3), np.uint8) colors[0,:] = 255 @@ -43,8 +41,15 @@ if __name__ == '__main__': cv.circle(img, (x, y), 1, c, -1) - cv.imshow('gaussian mixture', img) + cv.imshow('kmeans', img) ch = cv.waitKey(0) if ch == 27: break + + print('Done') + + +if __name__ == '__main__': + print(__doc__) + main() cv.destroyAllWindows() diff --git a/samples/python/lappyr.py b/samples/python/lappyr.py index 291251a665..2ee73ecb1d 100755 --- a/samples/python/lappyr.py +++ b/samples/python/lappyr.py @@ -22,6 +22,7 @@ if PY3: import numpy as np import cv2 as cv + import video from common import nothing, getsize @@ -44,9 +45,8 @@ def merge_lappyr(levels): return np.uint8(np.clip(img, 0, 255)) -if __name__ == '__main__': +def main(): import sys - print(__doc__) try: fn = sys.argv[1] @@ -72,3 +72,11 @@ if __name__ == '__main__': if cv.waitKey(1) == 27: break + + print('Done') + + +if __name__ == '__main__': + print(__doc__) + main() + cv.destroyAllWindows() diff --git a/samples/python/letter_recog.py b/samples/python/letter_recog.py index 67e4266f28..f646f178fc 100755 --- a/samples/python/letter_recog.py +++ b/samples/python/letter_recog.py @@ -145,12 +145,10 @@ class MLP(LetterStatModel): -if __name__ == '__main__': +def main(): import getopt import sys - print(__doc__) - models = [RTrees, KNearest, Boost, SVM, MLP] # NBayes models = dict( [(cls.__name__.lower(), cls) for cls in models] ) @@ -186,4 +184,11 @@ if __name__ == '__main__': fn = args['--save'] print('saving model to %s ...' % fn) model.save(fn) + + print('Done') + + +if __name__ == '__main__': + print(__doc__) + main() cv.destroyAllWindows() diff --git a/samples/python/lk_homography.py b/samples/python/lk_homography.py index 0da4761af2..808f30965f 100755 --- a/samples/python/lk_homography.py +++ b/samples/python/lk_homography.py @@ -25,6 +25,7 @@ from __future__ import print_function import numpy as np import cv2 as cv + import video from common import draw_str from video import presets @@ -112,9 +113,11 @@ def main(): except: video_src = 0 - print(__doc__) App(video_src).run() - cv.destroyAllWindows() + print('Done') + if __name__ == '__main__': + print(__doc__) main() + cv.destroyAllWindows() diff --git a/samples/python/lk_track.py b/samples/python/lk_track.py index 19e819f159..c668448b39 100755 --- a/samples/python/lk_track.py +++ b/samples/python/lk_track.py @@ -23,6 +23,7 @@ from __future__ import print_function import numpy as np import cv2 as cv + import video from common import anorm2, draw_str from time import clock @@ -96,9 +97,11 @@ def main(): except: video_src = 0 - print(__doc__) App(video_src).run() - cv.destroyAllWindows() + print('Done') + if __name__ == '__main__': + print(__doc__) main() + cv.destroyAllWindows() diff --git a/samples/python/logpolar.py b/samples/python/logpolar.py index 09b2cbc99f..0dc6b8ba42 100644 --- a/samples/python/logpolar.py +++ b/samples/python/logpolar.py @@ -13,11 +13,10 @@ Keys: # Python 2/3 compatibility from __future__ import print_function +import numpy as np import cv2 as cv -if __name__ == '__main__': - print(__doc__) - +def main(): import sys try: fn = sys.argv[1] @@ -37,3 +36,10 @@ if __name__ == '__main__': cv.imshow('linearpolar', img3) cv.waitKey(0) + print('Done') + + +if __name__ == '__main__': + print(__doc__) + main() + cv.destroyAllWindows() diff --git a/samples/python/morphology.py b/samples/python/morphology.py index e368c28576..9ecf5b0682 100755 --- a/samples/python/morphology.py +++ b/samples/python/morphology.py @@ -21,9 +21,7 @@ import numpy as np import cv2 as cv -if __name__ == '__main__': - print(__doc__) - +def main(): import sys from itertools import cycle from common import draw_str @@ -93,4 +91,11 @@ if __name__ == '__main__': else: cur_str_mode = str_modes.next() update() + + print('Done') + + +if __name__ == '__main__': + print(__doc__) + main() cv.destroyAllWindows() diff --git a/samples/python/mouse_and_match.py b/samples/python/mouse_and_match.py index aebca3c32c..0bc2fce76e 100755 --- a/samples/python/mouse_and_match.py +++ b/samples/python/mouse_and_match.py @@ -25,59 +25,64 @@ import argparse from math import * -drag_start = None -sel = (0,0,0,0) +class App(): + drag_start = None + sel = (0,0,0,0) + + def onmouse(self, event, x, y, flags, param): + if event == cv.EVENT_LBUTTONDOWN: + self.drag_start = x, y + self.sel = (0,0,0,0) + elif event == cv.EVENT_LBUTTONUP: + if self.sel[2] > self.sel[0] and self.sel[3] > self.sel[1]: + patch = self.gray[self.sel[1]:self.sel[3], self.sel[0]:self.sel[2]] + result = cv.matchTemplate(self.gray, patch, cv.TM_CCOEFF_NORMED) + result = np.abs(result)**3 + _val, result = cv.threshold(result, 0.01, 0, cv.THRESH_TOZERO) + result8 = cv.normalize(result, None, 0, 255, cv.NORM_MINMAX, cv.CV_8U) + cv.imshow("result", result8) + self.drag_start = None + elif self.drag_start: + #print flags + if flags & cv.EVENT_FLAG_LBUTTON: + minpos = min(self.drag_start[0], x), min(self.drag_start[1], y) + maxpos = max(self.drag_start[0], x), max(self.drag_start[1], y) + self.sel = (minpos[0], minpos[1], maxpos[0], maxpos[1]) + img = cv.cvtColor(self.gray, cv.COLOR_GRAY2BGR) + cv.rectangle(img, (self.sel[0], self.sel[1]), (self.sel[2], self.sel[3]), (0,255,255), 1) + cv.imshow("gray", img) + else: + print("selection is complete") + self.drag_start = None + + def run(self): + parser = argparse.ArgumentParser(description='Demonstrate mouse interaction with images') + parser.add_argument("-i","--input", default='../data/', help="Input directory.") + args = parser.parse_args() + path = args.input + + cv.namedWindow("gray",1) + cv.setMouseCallback("gray", self.onmouse) + '''Loop through all the images in the directory''' + for infile in glob.glob( os.path.join(path, '*.*') ): + ext = os.path.splitext(infile)[1][1:] #get the filename extension + if ext == "png" or ext == "jpg" or ext == "bmp" or ext == "tiff" or ext == "pbm": + print(infile) + + img = cv.imread(infile,1) + if img is None: + continue + self.sel = (0,0,0,0) + self.drag_start = None + self.gray = cv.cvtColor(img, cv.COLOR_BGR2GRAY) + cv.imshow("gray", self.gray) + if cv.waitKey() == 27: + break + + print('Done') -def onmouse(event, x, y, flags, param): - global drag_start, sel - if event == cv.EVENT_LBUTTONDOWN: - drag_start = x, y - sel = 0,0,0,0 - elif event == cv.EVENT_LBUTTONUP: - if sel[2] > sel[0] and sel[3] > sel[1]: - patch = gray[sel[1]:sel[3],sel[0]:sel[2]] - result = cv.matchTemplate(gray,patch,cv.TM_CCOEFF_NORMED) - result = np.abs(result)**3 - _val, result = cv.threshold(result, 0.01, 0, cv.THRESH_TOZERO) - result8 = cv.normalize(result,None,0,255,cv.NORM_MINMAX,cv.CV_8U) - cv.imshow("result", result8) - drag_start = None - elif drag_start: - #print flags - if flags & cv.EVENT_FLAG_LBUTTON: - minpos = min(drag_start[0], x), min(drag_start[1], y) - maxpos = max(drag_start[0], x), max(drag_start[1], y) - sel = minpos[0], minpos[1], maxpos[0], maxpos[1] - img = cv.cvtColor(gray, cv.COLOR_GRAY2BGR) - cv.rectangle(img, (sel[0], sel[1]), (sel[2], sel[3]), (0,255,255), 1) - cv.imshow("gray", img) - else: - print("selection is complete") - drag_start = None if __name__ == '__main__': print(__doc__) - - parser = argparse.ArgumentParser(description='Demonstrate mouse interaction with images') - parser.add_argument("-i","--input", default='../data/', help="Input directory.") - args = parser.parse_args() - path = args.input - - cv.namedWindow("gray",1) - cv.setMouseCallback("gray", onmouse) - '''Loop through all the images in the directory''' - for infile in glob.glob( os.path.join(path, '*.*') ): - ext = os.path.splitext(infile)[1][1:] #get the filename extension - if ext == "png" or ext == "jpg" or ext == "bmp" or ext == "tiff" or ext == "pbm": - print(infile) - - img=cv.imread(infile,1) - if img is None: - continue - sel = (0,0,0,0) - drag_start = None - gray=cv.cvtColor(img, cv.COLOR_BGR2GRAY) - cv.imshow("gray",gray) - if cv.waitKey() == 27: - break + App().run() cv.destroyAllWindows() diff --git a/samples/python/mser.py b/samples/python/mser.py index bf984d0751..929a31347b 100755 --- a/samples/python/mser.py +++ b/samples/python/mser.py @@ -14,12 +14,16 @@ Keys: ''' +# Python 2/3 compatibility +from __future__ import print_function + import numpy as np import cv2 as cv + import video import sys -if __name__ == '__main__': +def main(): try: video_src = sys.argv[1] except: @@ -42,4 +46,11 @@ if __name__ == '__main__': cv.imshow('img', vis) if cv.waitKey(5) == 27: break + + print('Done') + + +if __name__ == '__main__': + print(__doc__) + main() cv.destroyAllWindows() diff --git a/samples/python/opencv_version.py b/samples/python/opencv_version.py index 3e503a4e35..0763f79113 100644 --- a/samples/python/opencv_version.py +++ b/samples/python/opencv_version.py @@ -13,11 +13,11 @@ Usage: # Python 2/3 compatibility from __future__ import print_function +import numpy as np import cv2 as cv -if __name__ == '__main__': +def main(): import sys - print(__doc__) try: param = sys.argv[1] @@ -31,3 +31,11 @@ if __name__ == '__main__': print("\t--help\n\t\tprint this help") else: print("Welcome to OpenCV") + + print('Done') + + +if __name__ == '__main__': + print(__doc__) + main() + cv.destroyAllWindows() diff --git a/samples/python/opt_flow.py b/samples/python/opt_flow.py index c43c72697c..c4515582e7 100755 --- a/samples/python/opt_flow.py +++ b/samples/python/opt_flow.py @@ -18,6 +18,7 @@ from __future__ import print_function import numpy as np import cv2 as cv + import video @@ -55,9 +56,8 @@ def warp_flow(img, flow): res = cv.remap(img, flow, None, cv.INTER_LINEAR) return res -if __name__ == '__main__': +def main(): import sys - print(__doc__) try: fn = sys.argv[1] except IndexError: @@ -94,4 +94,11 @@ if __name__ == '__main__': if show_glitch: cur_glitch = img.copy() print('glitch is', ['off', 'on'][show_glitch]) + + print('Done') + + +if __name__ == '__main__': + print(__doc__) + main() cv.destroyAllWindows() diff --git a/samples/python/peopledetect.py b/samples/python/peopledetect.py index a6f0538daf..d2a7fdeee5 100755 --- a/samples/python/peopledetect.py +++ b/samples/python/peopledetect.py @@ -30,13 +30,11 @@ def draw_detections(img, rects, thickness = 1): cv.rectangle(img, (x+pad_w, y+pad_h), (x+w-pad_w, y+h-pad_h), (0, 255, 0), thickness) -if __name__ == '__main__': +def main(): import sys from glob import glob import itertools as it - print(__doc__) - hog = cv.HOGDescriptor() hog.setSVMDetector( cv.HOGDescriptor_getDefaultPeopleDetector() ) @@ -68,4 +66,11 @@ if __name__ == '__main__': ch = cv.waitKey() if ch == 27: break + + print('Done') + + +if __name__ == '__main__': + print(__doc__) + main() cv.destroyAllWindows() diff --git a/samples/python/squares.py b/samples/python/squares.py index 90e8af36a3..1e7ffb88a8 100755 --- a/samples/python/squares.py +++ b/samples/python/squares.py @@ -7,6 +7,7 @@ Loads several images sequentially and tries to find squares in each image. ''' # Python 2/3 compatibility +from __future__ import print_function import sys PY3 = sys.version_info[0] == 3 @@ -42,7 +43,7 @@ def find_squares(img): squares.append(cnt) return squares -if __name__ == '__main__': +def main(): from glob import glob for fn in glob('../data/pic*.png'): img = cv.imread(fn) @@ -52,4 +53,11 @@ if __name__ == '__main__': ch = cv.waitKey() if ch == 27: break + + print('Done') + + +if __name__ == '__main__': + print(__doc__) + main() cv.destroyAllWindows() diff --git a/samples/python/stereo_match.py b/samples/python/stereo_match.py index 2d539318f5..969ea11dbb 100755 --- a/samples/python/stereo_match.py +++ b/samples/python/stereo_match.py @@ -33,7 +33,7 @@ def write_ply(fn, verts, colors): np.savetxt(f, verts, fmt='%f %f %f %d %d %d ') -if __name__ == '__main__': +def main(): print('loading images...') imgL = cv.pyrDown(cv.imread(cv.samples.findFile('aloeL.jpg'))) # downscale images for faster processing imgR = cv.pyrDown(cv.imread(cv.samples.findFile('aloeR.jpg'))) @@ -75,4 +75,11 @@ if __name__ == '__main__': cv.imshow('left', imgL) cv.imshow('disparity', (disp-min_disp)/num_disp) cv.waitKey() + + print('Done') + + +if __name__ == '__main__': + print(__doc__) + main() cv.destroyAllWindows() diff --git a/samples/python/texture_flow.py b/samples/python/texture_flow.py index 70259a8129..33110858ea 100755 --- a/samples/python/texture_flow.py +++ b/samples/python/texture_flow.py @@ -16,7 +16,7 @@ from __future__ import print_function import numpy as np import cv2 as cv -if __name__ == '__main__': +def main(): import sys try: fn = sys.argv[1] @@ -45,3 +45,11 @@ if __name__ == '__main__': cv.imshow('input', img) cv.imshow('flow', vis) cv.waitKey() + + print('Done') + + +if __name__ == '__main__': + print(__doc__) + main() + cv.destroyAllWindows() diff --git a/samples/python/tst_scene_render.py b/samples/python/tst_scene_render.py index 33cbd0dc1c..9d09ea7b9e 100644 --- a/samples/python/tst_scene_render.py +++ b/samples/python/tst_scene_render.py @@ -5,9 +5,10 @@ from __future__ import print_function import numpy as np +import cv2 as cv + from numpy import pi, sin, cos -import cv2 as cv defaultSize = 512 @@ -86,7 +87,7 @@ class TestSceneRender(): else: self.currentRect = self.initialRect + np.int( 30*cos(self.time*self.speed) + 50*sin(self.time*self.speed)) if self.deformation: - self.currentRect[1:3] += self.h/20*cos(self.time) + self.currentRect[1:3] += int(self.h/20*cos(self.time)) cv.fillConvexPoly(img, self.currentRect, (0, 0, 255)) self.time += self.timeStep @@ -96,8 +97,7 @@ class TestSceneRender(): self.time = 0.0 -if __name__ == '__main__': - +def main(): backGr = cv.imread(cv.samples.findFile('graf1.png')) fgr = cv.imread(cv.samples.findFile('box.png')) @@ -111,6 +111,11 @@ if __name__ == '__main__': ch = cv.waitKey(3) if ch == 27: break - #import os - #print (os.environ['PYTHONPATH']) + + print('Done') + + +if __name__ == '__main__': + print(__doc__) + main() cv.destroyAllWindows() diff --git a/samples/python/turing.py b/samples/python/turing.py index 0d80cbab9b..27dbe02ad3 100755 --- a/samples/python/turing.py +++ b/samples/python/turing.py @@ -27,7 +27,7 @@ USAGE: turing.py [-o ] Press ESC to stop. ''' -if __name__ == '__main__': +def main(): print(help_message) w, h = 512, 512 @@ -71,4 +71,11 @@ if __name__ == '__main__': cv.imshow('a', vis) if cv.waitKey(5) == 27: break + + print('Done') + + +if __name__ == '__main__': + print(__doc__) + main() cv.destroyAllWindows() diff --git a/samples/python/tutorial_code/imgProc/anisotropic_image_segmentation/anisotropic_image_segmentation.py b/samples/python/tutorial_code/imgProc/anisotropic_image_segmentation/anisotropic_image_segmentation.py new file mode 100644 index 0000000000..5e2385a1ce --- /dev/null +++ b/samples/python/tutorial_code/imgProc/anisotropic_image_segmentation/anisotropic_image_segmentation.py @@ -0,0 +1,92 @@ + +import cv2 as cv +import numpy as np +import argparse + +W = 52 # window size is WxW +C_Thr = 0.43 # threshold for coherency +LowThr = 35 # threshold1 for orientation, it ranges from 0 to 180 +HighThr = 57 # threshold2 for orientation, it ranges from 0 to 180 + +## [calcGST] +## [calcJ_header] +## [calcGST_proto] +def calcGST(inputIMG, w): +## [calcGST_proto] + img = inputIMG.astype(np.float32) + + # GST components calculation (start) + # J = (J11 J12; J12 J22) - GST + imgDiffX = cv.Sobel(img, cv.CV_32F, 1, 0, 3) + imgDiffY = cv.Sobel(img, cv.CV_32F, 0, 1, 3) + imgDiffXY = cv.multiply(imgDiffX, imgDiffY) + ## [calcJ_header] + + imgDiffXX = cv.multiply(imgDiffX, imgDiffX) + imgDiffYY = cv.multiply(imgDiffY, imgDiffY) + + J11 = cv.boxFilter(imgDiffXX, cv.CV_32F, (w,w)) + J22 = cv.boxFilter(imgDiffYY, cv.CV_32F, (w,w)) + J12 = cv.boxFilter(imgDiffXY, cv.CV_32F, (w,w)) + # GST components calculations (stop) + + # eigenvalue calculation (start) + # lambda1 = J11 + J22 + sqrt((J11-J22)^2 + 4*J12^2) + # lambda2 = J11 + J22 - sqrt((J11-J22)^2 + 4*J12^2) + tmp1 = J11 + J22 + tmp2 = J11 - J22 + tmp2 = cv.multiply(tmp2, tmp2) + tmp3 = cv.multiply(J12, J12) + tmp4 = np.sqrt(tmp2 + 4.0 * tmp3) + + lambda1 = tmp1 + tmp4 # biggest eigenvalue + lambda2 = tmp1 - tmp4 # smallest eigenvalue + # eigenvalue calculation (stop) + + # Coherency calculation (start) + # Coherency = (lambda1 - lambda2)/(lambda1 + lambda2)) - measure of anisotropism + # Coherency is anisotropy degree (consistency of local orientation) + imgCoherencyOut = cv.divide(lambda1 - lambda2, lambda1 + lambda2) + # Coherency calculation (stop) + + # orientation angle calculation (start) + # tan(2*Alpha) = 2*J12/(J22 - J11) + # Alpha = 0.5 atan2(2*J12/(J22 - J11)) + imgOrientationOut = cv.phase(J22 - J11, 2.0 * J12, angleInDegrees = True) + imgOrientationOut = 0.5 * imgOrientationOut + # orientation angle calculation (stop) + + return imgCoherencyOut, imgOrientationOut +## [calcGST] + +parser = argparse.ArgumentParser(description='Code for Anisotropic image segmentation tutorial.') +parser.add_argument('-i', '--input', help='Path to input image.', required=True) +args = parser.parse_args() + +imgIn = cv.imread(args.input, cv.IMREAD_GRAYSCALE) +if imgIn is None: + print('Could not open or find the image: {}'.format(args.input)) + exit(0) + +## [main_extra] +## [main] +imgCoherency, imgOrientation = calcGST(imgIn, W) + +## [thresholding] +_, imgCoherencyBin = cv.threshold(imgCoherency, C_Thr, 255, cv.THRESH_BINARY) +_, imgOrientationBin = cv.threshold(imgOrientation, LowThr, HighThr, cv.THRESH_BINARY) +## [thresholding] + +## [combining] +imgBin = cv.bitwise_and(imgCoherencyBin, imgOrientationBin) +## [combining] +## [main] + +imgCoherency = cv.normalize(imgCoherency, None, alpha=0, beta=1, norm_type=cv.NORM_MINMAX, dtype=cv.CV_32F) +imgOrientation = cv.normalize(imgOrientation, None, alpha=0, beta=1, norm_type=cv.NORM_MINMAX, dtype=cv.CV_32F) + +cv.imshow('result.jpg', np.uint8(0.5*(imgIn + imgBin))) +cv.imshow('Coherency.jpg', imgCoherency) +cv.imshow('Orientation.jpg', imgOrientation) +cv.waitKey(0) +## [main_extra] diff --git a/samples/python/video.py b/samples/python/video.py index 50ba4743f9..684702ac1c 100755 --- a/samples/python/video.py +++ b/samples/python/video.py @@ -32,13 +32,13 @@ Keys: # Python 2/3 compatibility from __future__ import print_function +import numpy as np +import cv2 as cv + import re -import numpy as np from numpy import pi, sin, cos -import cv2 as cv - # built-in modules from time import clock diff --git a/samples/python/video_threaded.py b/samples/python/video_threaded.py index c95a5ba680..4886db3d80 100755 --- a/samples/python/video_threaded.py +++ b/samples/python/video_threaded.py @@ -36,11 +36,9 @@ class DummyTask: def get(self): return self.data -if __name__ == '__main__': +def main(): import sys - print(__doc__) - try: fn = sys.argv[1] except: @@ -86,4 +84,11 @@ if __name__ == '__main__': threaded_mode = not threaded_mode if ch == 27: break -cv.destroyAllWindows() + + print('Done') + + +if __name__ == '__main__': + print(__doc__) + main() + cv.destroyAllWindows() diff --git a/samples/python/video_v4l2.py b/samples/python/video_v4l2.py index d506833fe9..68f22699b1 100644 --- a/samples/python/video_v4l2.py +++ b/samples/python/video_v4l2.py @@ -17,51 +17,62 @@ Keys: # Python 2/3 compatibility from __future__ import print_function +import numpy as np import cv2 as cv -def decode_fourcc(v): - v = int(v) - return "".join([chr((v >> 8 * i) & 0xFF) for i in range(4)]) +def main(): -font = cv.FONT_HERSHEY_SIMPLEX -color = (0, 255, 0) + def decode_fourcc(v): + v = int(v) + return "".join([chr((v >> 8 * i) & 0xFF) for i in range(4)]) -cap = cv.VideoCapture(0) -cap.set(cv.CAP_PROP_AUTOFOCUS, False) # Known bug: https://github.com/opencv/opencv/pull/5474 + font = cv.FONT_HERSHEY_SIMPLEX + color = (0, 255, 0) -cv.namedWindow("Video") + cap = cv.VideoCapture(0) + cap.set(cv.CAP_PROP_AUTOFOCUS, False) # Known bug: https://github.com/opencv/opencv/pull/5474 -convert_rgb = True -fps = int(cap.get(cv.CAP_PROP_FPS)) -focus = int(min(cap.get(cv.CAP_PROP_FOCUS) * 100, 2**31-1)) # ceil focus to C_LONG as Python3 int can go to +inf + cv.namedWindow("Video") -cv.createTrackbar("FPS", "Video", fps, 30, lambda v: cap.set(cv.CAP_PROP_FPS, v)) -cv.createTrackbar("Focus", "Video", focus, 100, lambda v: cap.set(cv.CAP_PROP_FOCUS, v / 100)) + convert_rgb = True + fps = int(cap.get(cv.CAP_PROP_FPS)) + focus = int(min(cap.get(cv.CAP_PROP_FOCUS) * 100, 2**31-1)) # ceil focus to C_LONG as Python3 int can go to +inf -while True: - status, img = cap.read() + cv.createTrackbar("FPS", "Video", fps, 30, lambda v: cap.set(cv.CAP_PROP_FPS, v)) + cv.createTrackbar("Focus", "Video", focus, 100, lambda v: cap.set(cv.CAP_PROP_FOCUS, v / 100)) - fourcc = decode_fourcc(cap.get(cv.CAP_PROP_FOURCC)) + while True: + status, img = cap.read() - fps = cap.get(cv.CAP_PROP_FPS) + fourcc = decode_fourcc(cap.get(cv.CAP_PROP_FOURCC)) - if not bool(cap.get(cv.CAP_PROP_CONVERT_RGB)): - if fourcc == "MJPG": - img = cv.imdecode(img, cv.IMREAD_GRAYSCALE) - elif fourcc == "YUYV": - img = cv.cvtColor(img, cv.COLOR_YUV2GRAY_YUYV) - else: - print("unsupported format") + fps = cap.get(cv.CAP_PROP_FPS) + + if not bool(cap.get(cv.CAP_PROP_CONVERT_RGB)): + if fourcc == "MJPG": + img = cv.imdecode(img, cv.IMREAD_GRAYSCALE) + elif fourcc == "YUYV": + img = cv.cvtColor(img, cv.COLOR_YUV2GRAY_YUYV) + else: + print("unsupported format") + break + + cv.putText(img, "Mode: {}".format(fourcc), (15, 40), font, 1.0, color) + cv.putText(img, "FPS: {}".format(fps), (15, 80), font, 1.0, color) + cv.imshow("Video", img) + + k = cv.waitKey(1) + + if k == 27: break + elif k == ord('g'): + convert_rgb = not convert_rgb + cap.set(cv.CAP_PROP_CONVERT_RGB, convert_rgb) - cv.putText(img, "Mode: {}".format(fourcc), (15, 40), font, 1.0, color) - cv.putText(img, "FPS: {}".format(fps), (15, 80), font, 1.0, color) - cv.imshow("Video", img) + print('Done') - k = cv.waitKey(1) - if k == 27: - break - elif k == ord('g'): - convert_rgb = not convert_rgb - cap.set(cv.CAP_PROP_CONVERT_RGB, convert_rgb) +if __name__ == '__main__': + print(__doc__) + main() + cv.destroyAllWindows() diff --git a/samples/python/watershed.py b/samples/python/watershed.py index b2bfbddcf9..7c71c81502 100755 --- a/samples/python/watershed.py +++ b/samples/python/watershed.py @@ -76,10 +76,10 @@ class App: if __name__ == '__main__': + print(__doc__) import sys try: fn = sys.argv[1] except: fn = 'fruits.jpg' - print(__doc__) App(cv.samples.findFile(fn)).run()