mirror of
https://github.com/opencv/opencv.git
synced 2024-11-24 03:00:14 +08:00
Merge remote-tracking branch 'upstream/3.4' into merge-3.4
This commit is contained in:
Alexander Alekhin
commit
bea2c75452
@ -305,10 +305,13 @@ fi
|
||||
${_command} '-D$<JOIN:$<TARGET_PROPERTY:${_targetName},COMPILE_DEFINITIONS>,' '-D>'
|
||||
")
|
||||
GET_FILENAME_COMPONENT(_outdir ${_output} PATH)
|
||||
if(NOT CMAKE_HOST_WIN32) # chmod may be not available on Win32/MinGW (and it is not required)
|
||||
set(_pch_prepare_command COMMAND chmod +x "${_pch_generate_file_cmd}")
|
||||
endif()
|
||||
ADD_CUSTOM_COMMAND(
|
||||
OUTPUT "${_output}"
|
||||
COMMAND ${CMAKE_COMMAND} -E make_directory "${_outdir}"
|
||||
COMMAND chmod +x "${_pch_generate_file_cmd}"
|
||||
${_pch_prepare_command}
|
||||
COMMAND "${_pch_generate_file_cmd}"
|
||||
DEPENDS "${_input}" "${_pch_generate_file_cmd}"
|
||||
DEPENDS "${CMAKE_CURRENT_BINARY_DIR}/${_name}"
|
||||
|
||||
@ -147,7 +147,7 @@ if(DOXYGEN_FOUND)
|
||||
|
||||
# set export variables
|
||||
string(REPLACE ";" " \\\n" CMAKE_DOXYGEN_INPUT_LIST "${rootfile} ; ${faqfile} ; ${paths_include} ; ${paths_hal_interface} ; ${paths_doc} ; ${tutorial_path} ; ${tutorial_py_path} ; ${tutorial_js_path} ; ${paths_tutorial} ; ${tutorial_contrib_root}")
|
||||
string(REPLACE ";" " \\\n" CMAKE_DOXYGEN_IMAGE_PATH "${paths_doc} ; ${tutorial_path} ; ${tutorial_py_path} ; ${tutorial_js_path} ; ${paths_tutorial}")
|
||||
string(REPLACE ";" " \\\n" CMAKE_DOXYGEN_IMAGE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/images ; ${paths_doc} ; ${tutorial_path} ; ${tutorial_py_path} ; ${tutorial_js_path} ; ${paths_tutorial}")
|
||||
string(REPLACE ";" " \\\n" CMAKE_DOXYGEN_EXCLUDE_LIST "${CMAKE_DOXYGEN_EXCLUDE_LIST}")
|
||||
string(REPLACE ";" " " CMAKE_DOXYGEN_ENABLED_SECTIONS "${CMAKE_DOXYGEN_ENABLED_SECTIONS}")
|
||||
# TODO: remove paths_doc from EXAMPLE_PATH after face module tutorials/samples moved to separate folders
|
||||
|
||||
@ -266,9 +266,7 @@ GENERATE_TAGFILE = @CMAKE_DOXYGEN_OUTPUT_PATH@/html/opencv.tag
|
||||
ALLEXTERNALS = NO
|
||||
EXTERNAL_GROUPS = YES
|
||||
EXTERNAL_PAGES = YES
|
||||
PERL_PATH = /usr/bin/perl
|
||||
CLASS_DIAGRAMS = YES
|
||||
MSCGEN_PATH =
|
||||
DIA_PATH =
|
||||
HIDE_UNDOC_RELATIONS = NO
|
||||
HAVE_DOT = NO
|
||||
|
||||
|
Before Width: | Height: | Size: 247 KiB After Width: | Height: | Size: 247 KiB |
|
Before Width: | Height: | Size: 34 KiB After Width: | Height: | Size: 34 KiB |
|
Before Width: | Height: | Size: 17 KiB After Width: | Height: | Size: 17 KiB |
|
Before Width: | Height: | Size: 176 KiB After Width: | Height: | Size: 176 KiB |
|
Before Width: | Height: | Size: 27 KiB After Width: | Height: | Size: 27 KiB |
|
Before Width: | Height: | Size: 6.0 KiB After Width: | Height: | Size: 6.0 KiB |
|
Before Width: | Height: | Size: 24 KiB After Width: | Height: | Size: 24 KiB |
|
Before Width: | Height: | Size: 22 KiB After Width: | Height: | Size: 22 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 606 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 12 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 5.6 KiB After Width: | Height: | Size: 12 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 4.8 KiB After Width: | Height: | Size: 19 KiB |
|
Before Width: | Height: | Size: 17 KiB After Width: | Height: | Size: 17 KiB |
|
Before Width: | Height: | Size: 606 KiB After Width: | Height: | Size: 606 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 19 KiB |
@ -50,7 +50,7 @@ Now we will learn how to write a simple Hello World Application in Xcode using O
|
||||
Output
|
||||
------
|
||||
|
||||
|
||||
|
||||
|
||||
Changes for XCode5+ and iOS8+
|
||||
-----------------------------
|
||||
|
||||
|
Before Width: | Height: | Size: 88 KiB After Width: | Height: | Size: 88 KiB |
|
Before Width: | Height: | Size: 203 KiB After Width: | Height: | Size: 203 KiB |
@ -205,4 +205,4 @@ The code opens an image, finds the orientation of the detected objects of intere
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 247 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 17 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 176 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 6.0 KiB |
@ -73,8 +73,10 @@
|
||||
@defgroup core_cluster Clustering
|
||||
@defgroup core_utils Utility and system functions and macros
|
||||
@{
|
||||
@defgroup core_logging Logging facilities
|
||||
@defgroup core_utils_sse SSE utilities
|
||||
@defgroup core_utils_neon NEON utilities
|
||||
@defgroup core_utils_vsx VSX utilities
|
||||
@defgroup core_utils_softfloat Softfloat support
|
||||
@defgroup core_utils_samples Utility functions for OpenCV samples
|
||||
@}
|
||||
|
||||
@ -1039,6 +1039,15 @@ inline v_float64x2 v_cvt_f64(const v_float32x4& a)
|
||||
inline v_float64x2 v_cvt_f64_high(const v_float32x4& a)
|
||||
{ return v_float64x2(vec_cvfo(vec_mergel(a.val, a.val))); }
|
||||
|
||||
// The altivec intrinsic is missing for this 2.06 insn
|
||||
inline v_float64x2 v_cvt_f64(const v_int64x2& a)
|
||||
{
|
||||
vec_double2 out;
|
||||
|
||||
__asm__ ("xvcvsxddp %x0,%x1" : "=wa"(out) : "wa"(a.val));
|
||||
return v_float64x2(out);
|
||||
}
|
||||
|
||||
////////////// Lookup table access ////////////////////
|
||||
|
||||
inline v_int8x16 v_lut(const schar* tab, const int* idx)
|
||||
|
||||
@ -507,8 +507,8 @@ Special cases:
|
||||
*/
|
||||
CV_EXPORTS softdouble cos( const softdouble& a );
|
||||
|
||||
}
|
||||
//! @} core_utils_softfloat
|
||||
|
||||
//! @}
|
||||
} // cv::
|
||||
|
||||
#endif
|
||||
|
||||
@ -12,15 +12,13 @@
|
||||
#include "logger.defines.hpp"
|
||||
#include "logtag.hpp"
|
||||
|
||||
//! @addtogroup core_logging
|
||||
// This section describes OpenCV logging utilities.
|
||||
//
|
||||
//! @{
|
||||
|
||||
namespace cv {
|
||||
namespace utils {
|
||||
namespace logging {
|
||||
|
||||
//! @addtogroup core_logging
|
||||
//! @{
|
||||
|
||||
/** Set global logging level
|
||||
@return previous logging level
|
||||
*/
|
||||
@ -148,8 +146,8 @@ struct LogTagAuto
|
||||
# define CV_LOG_VERBOSE(tag, v, ...)
|
||||
#endif
|
||||
|
||||
}}} // namespace
|
||||
|
||||
//! @}
|
||||
|
||||
}}} // namespace
|
||||
|
||||
#endif // OPENCV_LOGGER_HPP
|
||||
|
||||
@ -7,15 +7,13 @@
|
||||
|
||||
#include <opencv2/core/cvdef.h>
|
||||
|
||||
//! @addtogroup core_logging
|
||||
// This section describes OpenCV tracing utilities.
|
||||
//
|
||||
//! @{
|
||||
|
||||
namespace cv {
|
||||
namespace utils {
|
||||
namespace trace {
|
||||
|
||||
//! @addtogroup core_logging
|
||||
//! @{
|
||||
|
||||
//! Macro to trace function
|
||||
#define CV_TRACE_FUNCTION()
|
||||
|
||||
@ -247,8 +245,8 @@ CV_EXPORTS void traceArg(const TraceArg& arg, double value);
|
||||
|
||||
//! @endcond
|
||||
|
||||
}}} // namespace
|
||||
|
||||
//! @}
|
||||
|
||||
}}} // namespace
|
||||
|
||||
#endif // OPENCV_TRACE_HPP
|
||||
|
||||
@ -2493,7 +2493,36 @@ double dotProd_16s(const short* src1, const short* src2, int len)
|
||||
|
||||
double dotProd_32s(const int* src1, const int* src2, int len)
|
||||
{
|
||||
#if CV_SIMD128_64F
|
||||
double r = 0.0;
|
||||
int i = 0;
|
||||
int lenAligned = len & -v_int32x4::nlanes;
|
||||
v_float64x2 a(0.0, 0.0);
|
||||
v_float64x2 b(0.0, 0.0);
|
||||
|
||||
for( i = 0; i < lenAligned; i += v_int32x4::nlanes )
|
||||
{
|
||||
v_int32x4 s1 = v_load(src1);
|
||||
v_int32x4 s2 = v_load(src2);
|
||||
|
||||
#if CV_VSX
|
||||
// Do 32x32->64 multiplies, convert/round to double, accumulate
|
||||
// Potentially less precise than FMA, but 1.5x faster than fma below.
|
||||
a += v_cvt_f64(v_int64(vec_mule(s1.val, s2.val)));
|
||||
b += v_cvt_f64(v_int64(vec_mulo(s1.val, s2.val)));
|
||||
#else
|
||||
a = v_fma(v_cvt_f64(s1), v_cvt_f64(s2), a);
|
||||
b = v_fma(v_cvt_f64_high(s1), v_cvt_f64_high(s2), b);
|
||||
#endif
|
||||
src1 += v_int32x4::nlanes;
|
||||
src2 += v_int32x4::nlanes;
|
||||
}
|
||||
a += b;
|
||||
r = v_reduce_sum(a);
|
||||
return r + dotProd_(src1, src2, len - i);
|
||||
#else
|
||||
return dotProd_(src1, src2, len);
|
||||
#endif
|
||||
}
|
||||
|
||||
double dotProd_32f(const float* src1, const float* src2, int len)
|
||||
|
||||
@ -63,7 +63,31 @@ int normHamming(const uchar* a, int n, int cellSize)
|
||||
return -1;
|
||||
int i = 0;
|
||||
int result = 0;
|
||||
#if CV_ENABLE_UNROLLED
|
||||
#if CV_SIMD
|
||||
v_uint64 t = vx_setzero_u64();
|
||||
if ( cellSize == 2)
|
||||
{
|
||||
v_uint16 mask = v_reinterpret_as_u16(vx_setall_u8(0x55));
|
||||
for(; i <= n - v_uint8::nlanes; i += v_uint8::nlanes)
|
||||
{
|
||||
v_uint16 a0 = v_reinterpret_as_u16(vx_load(a + i));
|
||||
t += v_popcount(v_reinterpret_as_u64((a0 | (a0 >> 1)) & mask));
|
||||
}
|
||||
}
|
||||
else // cellSize == 4
|
||||
{
|
||||
v_uint16 mask = v_reinterpret_as_u16(vx_setall_u8(0x11));
|
||||
for(; i <= n - v_uint8::nlanes; i += v_uint8::nlanes)
|
||||
{
|
||||
v_uint16 a0 = v_reinterpret_as_u16(vx_load(a + i));
|
||||
v_uint16 a1 = a0 | (a0 >> 2);
|
||||
t += v_popcount(v_reinterpret_as_u64((a1 | (a1 >> 1)) & mask));
|
||||
|
||||
}
|
||||
}
|
||||
result += (int)v_reduce_sum(t);
|
||||
vx_cleanup();
|
||||
#elif CV_ENABLE_UNROLLED
|
||||
for( ; i <= n - 4; i += 4 )
|
||||
result += tab[a[i]] + tab[a[i+1]] + tab[a[i+2]] + tab[a[i+3]];
|
||||
#endif
|
||||
@ -85,7 +109,30 @@ int normHamming(const uchar* a, const uchar* b, int n, int cellSize)
|
||||
return -1;
|
||||
int i = 0;
|
||||
int result = 0;
|
||||
#if CV_ENABLE_UNROLLED
|
||||
#if CV_SIMD
|
||||
v_uint64 t = vx_setzero_u64();
|
||||
if ( cellSize == 2)
|
||||
{
|
||||
v_uint16 mask = v_reinterpret_as_u16(vx_setall_u8(0x55));
|
||||
for(; i <= n - v_uint8::nlanes; i += v_uint8::nlanes)
|
||||
{
|
||||
v_uint16 ab0 = v_reinterpret_as_u16(vx_load(a + i) ^ vx_load(b + i));
|
||||
t += v_popcount(v_reinterpret_as_u64((ab0 | (ab0 >> 1)) & mask));
|
||||
}
|
||||
}
|
||||
else // cellSize == 4
|
||||
{
|
||||
v_uint16 mask = v_reinterpret_as_u16(vx_setall_u8(0x11));
|
||||
for(; i <= n - v_uint8::nlanes; i += v_uint8::nlanes)
|
||||
{
|
||||
v_uint16 ab0 = v_reinterpret_as_u16(vx_load(a + i) ^ vx_load(b + i));
|
||||
v_uint16 ab1 = ab0 | (ab0 >> 2);
|
||||
t += v_popcount(v_reinterpret_as_u64((ab1 | (ab1 >> 1)) & mask));
|
||||
}
|
||||
}
|
||||
result += (int)v_reduce_sum(t);
|
||||
vx_cleanup();
|
||||
#elif CV_ENABLE_UNROLLED
|
||||
for( ; i <= n - 4; i += 4 )
|
||||
result += tab[a[i] ^ b[i]] + tab[a[i+1] ^ b[i+1]] +
|
||||
tab[a[i+2] ^ b[i+2]] + tab[a[i+3] ^ b[i+3]];
|
||||
@ -99,13 +146,20 @@ float normL2Sqr_(const float* a, const float* b, int n)
|
||||
{
|
||||
int j = 0; float d = 0.f;
|
||||
#if CV_SIMD
|
||||
v_float32 v_d = vx_setzero_f32();
|
||||
for (; j <= n - v_float32::nlanes; j += v_float32::nlanes)
|
||||
v_float32 v_d0 = vx_setzero_f32(), v_d1 = vx_setzero_f32();
|
||||
v_float32 v_d2 = vx_setzero_f32(), v_d3 = vx_setzero_f32();
|
||||
for (; j <= n - 4 * v_float32::nlanes; j += 4 * v_float32::nlanes)
|
||||
{
|
||||
v_float32 t = vx_load(a + j) - vx_load(b + j);
|
||||
v_d = v_muladd(t, t, v_d);
|
||||
v_float32 t0 = vx_load(a + j) - vx_load(b + j);
|
||||
v_float32 t1 = vx_load(a + j + v_float32::nlanes) - vx_load(b + j + v_float32::nlanes);
|
||||
v_float32 t2 = vx_load(a + j + 2 * v_float32::nlanes) - vx_load(b + j + 2 * v_float32::nlanes);
|
||||
v_float32 t3 = vx_load(a + j + 3 * v_float32::nlanes) - vx_load(b + j + 3 * v_float32::nlanes);
|
||||
v_d0 = v_muladd(t0, t0, v_d0);
|
||||
v_d1 = v_muladd(t1, t1, v_d1);
|
||||
v_d2 = v_muladd(t2, t2, v_d2);
|
||||
v_d3 = v_muladd(t3, t3, v_d3);
|
||||
}
|
||||
d = v_reduce_sum(v_d);
|
||||
d = v_reduce_sum(v_d0 + v_d1 + v_d2 + v_d3);
|
||||
#endif
|
||||
for( ; j < n; j++ )
|
||||
{
|
||||
@ -120,10 +174,16 @@ float normL1_(const float* a, const float* b, int n)
|
||||
{
|
||||
int j = 0; float d = 0.f;
|
||||
#if CV_SIMD
|
||||
v_float32 v_d = vx_setzero_f32();
|
||||
for (; j <= n - v_float32::nlanes; j += v_float32::nlanes)
|
||||
v_d += v_absdiff(vx_load(a + j), vx_load(b + j));
|
||||
d = v_reduce_sum(v_d);
|
||||
v_float32 v_d0 = vx_setzero_f32(), v_d1 = vx_setzero_f32();
|
||||
v_float32 v_d2 = vx_setzero_f32(), v_d3 = vx_setzero_f32();
|
||||
for (; j <= n - 4 * v_float32::nlanes; j += 4 * v_float32::nlanes)
|
||||
{
|
||||
v_d0 += v_absdiff(vx_load(a + j), vx_load(b + j));
|
||||
v_d1 += v_absdiff(vx_load(a + j + v_float32::nlanes), vx_load(b + j + v_float32::nlanes));
|
||||
v_d2 += v_absdiff(vx_load(a + j + 2 * v_float32::nlanes), vx_load(b + j + 2 * v_float32::nlanes));
|
||||
v_d3 += v_absdiff(vx_load(a + j + 3 * v_float32::nlanes), vx_load(b + j + 3 * v_float32::nlanes));
|
||||
}
|
||||
d = v_reduce_sum(v_d0 + v_d1 + v_d2 + v_d3);
|
||||
#endif
|
||||
for( ; j < n; j++ )
|
||||
d += std::abs(a[j] - b[j]);
|
||||
@ -134,8 +194,11 @@ int normL1_(const uchar* a, const uchar* b, int n)
|
||||
{
|
||||
int j = 0, d = 0;
|
||||
#if CV_SIMD
|
||||
for (; j <= n - v_uint8::nlanes; j += v_uint8::nlanes)
|
||||
d += v_reduce_sad(vx_load(a + j), vx_load(b + j));
|
||||
for (; j <= n - 4 * v_uint8::nlanes; j += 4 * v_uint8::nlanes)
|
||||
d += v_reduce_sad(vx_load(a + j), vx_load(b + j)) +
|
||||
v_reduce_sad(vx_load(a + j + v_uint8::nlanes), vx_load(b + j + v_uint8::nlanes)) +
|
||||
v_reduce_sad(vx_load(a + j + 2 * v_uint8::nlanes), vx_load(b + j + 2 * v_uint8::nlanes)) +
|
||||
v_reduce_sad(vx_load(a + j + 3 * v_uint8::nlanes), vx_load(b + j + 3 * v_uint8::nlanes));
|
||||
#endif
|
||||
for( ; j < n; j++ )
|
||||
d += std::abs(a[j] - b[j]);
|
||||
|
||||
@ -536,9 +536,9 @@ __kernel void fft_multi_radix_rows(__global const uchar* src_ptr, int src_step,
|
||||
const int x = get_global_id(0);
|
||||
const int y = get_group_id(1);
|
||||
const int block_size = LOCAL_SIZE/kercn;
|
||||
__local CT smem[LOCAL_SIZE]; // used in (y < nz) code branch only, but should be declared in the outermost scope of a kernel function
|
||||
if (y < nz)
|
||||
{
|
||||
__local CT smem[LOCAL_SIZE];
|
||||
__global const CT* twiddles = (__global const CT*)(twiddles_ptr + twiddles_offset);
|
||||
const int ind = x;
|
||||
#ifdef IS_1D
|
||||
@ -615,9 +615,9 @@ __kernel void fft_multi_radix_cols(__global const uchar* src_ptr, int src_step,
|
||||
const int x = get_group_id(0);
|
||||
const int y = get_global_id(1);
|
||||
|
||||
__local CT smem[LOCAL_SIZE]; // used in (x < nz) code branch only, but should be declared in the outermost scope of a kernel function
|
||||
if (x < nz)
|
||||
{
|
||||
__local CT smem[LOCAL_SIZE];
|
||||
__global const uchar* src = src_ptr + mad24(y, src_step, mad24(x, (int)(sizeof(CT)), src_offset));
|
||||
__global const CT* twiddles = (__global const CT*)(twiddles_ptr + twiddles_offset);
|
||||
const int ind = y;
|
||||
@ -682,9 +682,9 @@ __kernel void ifft_multi_radix_rows(__global const uchar* src_ptr, int src_step,
|
||||
const FT scale = (FT) 1/(dst_cols*dst_rows);
|
||||
#endif
|
||||
|
||||
__local CT smem[LOCAL_SIZE]; // used in (y < nz) code branch only, but should be declared in the outermost scope of a kernel function
|
||||
if (y < nz)
|
||||
{
|
||||
__local CT smem[LOCAL_SIZE];
|
||||
__global const CT* twiddles = (__global const CT*)(twiddles_ptr + twiddles_offset);
|
||||
const int ind = x;
|
||||
|
||||
@ -782,10 +782,10 @@ __kernel void ifft_multi_radix_cols(__global const uchar* src_ptr, int src_step,
|
||||
const int x = get_group_id(0);
|
||||
const int y = get_global_id(1);
|
||||
|
||||
#ifdef COMPLEX_INPUT
|
||||
__local CT smem[LOCAL_SIZE]; // used in (x < nz) code branch only, but should be declared in the outermost scope of a kernel function
|
||||
if (x < nz)
|
||||
{
|
||||
__local CT smem[LOCAL_SIZE];
|
||||
#ifdef COMPLEX_INPUT
|
||||
__global const uchar* src = src_ptr + mad24(y, src_step, mad24(x, (int)(sizeof(CT)), src_offset));
|
||||
__global uchar* dst = dst_ptr + mad24(y, dst_step, mad24(x, (int)(sizeof(CT)), dst_offset));
|
||||
__global const CT* twiddles = (__global const CT*)(twiddles_ptr + twiddles_offset);
|
||||
@ -812,15 +812,11 @@ __kernel void ifft_multi_radix_cols(__global const uchar* src_ptr, int src_step,
|
||||
res[0].x = smem[y + i*block_size].x;
|
||||
res[0].y = -smem[y + i*block_size].y;
|
||||
}
|
||||
}
|
||||
#else
|
||||
if (x < nz)
|
||||
{
|
||||
__global const CT* twiddles = (__global const CT*)(twiddles_ptr + twiddles_offset);
|
||||
const int ind = y;
|
||||
const int block_size = LOCAL_SIZE/kercn;
|
||||
|
||||
__local CT smem[LOCAL_SIZE];
|
||||
#ifdef EVEN
|
||||
if (x!=0 && (x!=(nz-1)))
|
||||
#else
|
||||
@ -877,6 +873,6 @@ __kernel void ifft_multi_radix_cols(__global const uchar* src_ptr, int src_step,
|
||||
res[0].x = smem[y + i*block_size].x;
|
||||
res[0].y = -smem[y + i*block_size].y;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -155,7 +155,7 @@ static void* WinGetProcAddress(const char* name)
|
||||
#define CV_CL_GET_PROC_ADDRESS(name) WinGetProcAddress(name)
|
||||
#endif // _WIN32
|
||||
|
||||
#if defined(__linux__)
|
||||
#if defined(__linux__) || defined(__FreeBSD__)
|
||||
#include <dlfcn.h>
|
||||
#include <stdio.h>
|
||||
|
||||
|
||||
@ -39,6 +39,7 @@ int normHamming(const uchar* a, int n)
|
||||
for (; i <= n - v_uint8::nlanes; i += v_uint8::nlanes)
|
||||
t += v_popcount(v_reinterpret_as_u64(vx_load(a + i)));
|
||||
result = (int)v_reduce_sum(t);
|
||||
vx_cleanup();
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
@ -1619,11 +1619,37 @@ struct Net::Impl
|
||||
Ptr<Layer> layer = ld.layerInstance;
|
||||
if (!fused && !layer->supportBackend(preferableBackend))
|
||||
{
|
||||
addInfEngineNetOutputs(ld);
|
||||
net = Ptr<InfEngineBackendNet>();
|
||||
netBlobsWrappers.clear(); // Is not used for R5 release but we don't wrap it to #ifdef.
|
||||
layer->preferableTarget = DNN_TARGET_CPU;
|
||||
continue;
|
||||
bool customizable = ld.id != 0 && ld.outputBlobs.size() == 1;
|
||||
// TODO: there is a bug in Myriad plugin with custom layers shape infer.
|
||||
if (preferableTarget == DNN_TARGET_MYRIAD)
|
||||
{
|
||||
for (int i = 0; customizable && i < ld.inputBlobs.size(); ++i)
|
||||
{
|
||||
customizable = ld.inputBlobs[i]->size[0] == 1;
|
||||
}
|
||||
}
|
||||
|
||||
// TODO: fix these workarounds
|
||||
if (preferableTarget == DNN_TARGET_MYRIAD ||
|
||||
preferableTarget == DNN_TARGET_OPENCL ||
|
||||
preferableTarget == DNN_TARGET_OPENCL_FP16)
|
||||
customizable &= ld.type != "Concat";
|
||||
|
||||
if (preferableTarget == DNN_TARGET_OPENCL ||
|
||||
preferableTarget == DNN_TARGET_OPENCL_FP16)
|
||||
customizable &= ld.type != "Power";
|
||||
|
||||
if (preferableTarget == DNN_TARGET_OPENCL)
|
||||
customizable &= ld.type != "Eltwise";
|
||||
|
||||
if (!customizable)
|
||||
{
|
||||
addInfEngineNetOutputs(ld);
|
||||
net = Ptr<InfEngineBackendNet>();
|
||||
netBlobsWrappers.clear(); // Is not used for R5 release but we don't wrap it to #ifdef.
|
||||
layer->preferableTarget = DNN_TARGET_CPU;
|
||||
continue;
|
||||
}
|
||||
}
|
||||
ld.skip = true; // Initially skip all Inference Engine supported layers.
|
||||
|
||||
@ -1662,7 +1688,13 @@ struct Net::Impl
|
||||
|
||||
if (!fused)
|
||||
{
|
||||
node = layer->initInfEngine(ld.inputBlobsWrappers);
|
||||
if (layer->supportBackend(preferableBackend))
|
||||
node = layer->initInfEngine(ld.inputBlobsWrappers);
|
||||
else
|
||||
{
|
||||
node = Ptr<BackendNode>(new InfEngineBackendNode(
|
||||
ld.layerInstance, ld.inputBlobs, ld.outputBlobs, ld.internals));
|
||||
}
|
||||
}
|
||||
else if (node.empty())
|
||||
continue;
|
||||
|
||||
@ -6,6 +6,7 @@
|
||||
// Third party copyrights are property of their respective owners.
|
||||
|
||||
#include "../precomp.hpp"
|
||||
#include "../op_inf_engine.hpp"
|
||||
#include "layers_common.hpp"
|
||||
|
||||
#ifdef HAVE_OPENCL
|
||||
@ -23,6 +24,11 @@ public:
|
||||
CV_Assert(blobs.size() == 1);
|
||||
}
|
||||
|
||||
virtual bool supportBackend(int backendId) CV_OVERRIDE
|
||||
{
|
||||
return backendId == DNN_BACKEND_OPENCV || backendId == DNN_BACKEND_INFERENCE_ENGINE;
|
||||
}
|
||||
|
||||
virtual bool getMemoryShapes(const std::vector<MatShape> &inputs,
|
||||
const int requiredOutputs,
|
||||
std::vector<MatShape> &outputs,
|
||||
@ -58,6 +64,15 @@ public:
|
||||
outputs_arr.getMatVector(outputs);
|
||||
blobs[0].copyTo(outputs[0]);
|
||||
}
|
||||
|
||||
#ifdef HAVE_INF_ENGINE
|
||||
virtual Ptr<BackendNode> initInfEngine(const std::vector<Ptr<BackendWrapper> >&) CV_OVERRIDE
|
||||
{
|
||||
InferenceEngine::Builder::ConstLayer ieLayer(name);
|
||||
ieLayer.setData(wrapToInfEngineBlob(blobs[0]));
|
||||
return Ptr<BackendNode>(new InfEngineBackendNode(ieLayer));
|
||||
}
|
||||
#endif // HAVE_INF_ENGINE
|
||||
};
|
||||
|
||||
Ptr<Layer> ConstLayer::create(const LayerParams& params)
|
||||
|
||||
@ -14,6 +14,7 @@ class CropAndResizeLayerImpl CV_FINAL : public CropAndResizeLayer
|
||||
public:
|
||||
CropAndResizeLayerImpl(const LayerParams& params)
|
||||
{
|
||||
setParamsFrom(params);
|
||||
CV_Assert_N(params.has("width"), params.has("height"));
|
||||
outWidth = params.get<float>("width");
|
||||
outHeight = params.get<float>("height");
|
||||
|
||||
@ -927,7 +927,7 @@ public:
|
||||
ieLayer.setShareLocation(_shareLocation);
|
||||
ieLayer.setBackgroudLabelId(_backgroundLabelId);
|
||||
ieLayer.setNMSThreshold(_nmsThreshold);
|
||||
ieLayer.setTopK(_topK);
|
||||
ieLayer.setTopK(_topK > 0 ? _topK : _keepTopK);
|
||||
ieLayer.setKeepTopK(_keepTopK);
|
||||
ieLayer.setConfidenceThreshold(_confidenceThreshold);
|
||||
ieLayer.setVariantEncodedInTarget(_varianceEncodedInTarget);
|
||||
|
||||
@ -25,10 +25,186 @@ namespace cv { namespace dnn {
|
||||
// OpenCV lets users use an empty input name and to prevent unexpected naming,
|
||||
// we can use some predefined name.
|
||||
static std::string kDefaultInpLayerName = "empty_inp_layer_name";
|
||||
static std::string kOpenCVLayersType = "OpenCVLayer";
|
||||
|
||||
static std::string shapesToStr(const std::vector<Mat>& mats)
|
||||
{
|
||||
std::ostringstream shapes;
|
||||
shapes << mats.size() << " ";
|
||||
for (const Mat& m : mats)
|
||||
{
|
||||
shapes << m.dims << " ";
|
||||
for (int i = 0; i < m.dims; ++i)
|
||||
shapes << m.size[i] << " ";
|
||||
}
|
||||
return shapes.str();
|
||||
}
|
||||
|
||||
static void strToShapes(const std::string& str, std::vector<std::vector<size_t> >& shapes)
|
||||
{
|
||||
std::istringstream ss(str);
|
||||
int num, dims;
|
||||
ss >> num;
|
||||
shapes.resize(num);
|
||||
for (int i = 0; i < num; ++i)
|
||||
{
|
||||
ss >> dims;
|
||||
shapes[i].resize(dims);
|
||||
for (int j = 0; j < dims; ++j)
|
||||
ss >> shapes[i][j];
|
||||
}
|
||||
}
|
||||
|
||||
class InfEngineCustomLayer : public InferenceEngine::ILayerExecImpl
|
||||
{
|
||||
public:
|
||||
explicit InfEngineCustomLayer(const InferenceEngine::CNNLayer& layer) : cnnLayer(layer)
|
||||
{
|
||||
std::istringstream iss(layer.GetParamAsString("impl"));
|
||||
size_t ptr;
|
||||
iss >> ptr;
|
||||
cvLayer = (Layer*)ptr;
|
||||
|
||||
std::vector<std::vector<size_t> > shapes;
|
||||
strToShapes(layer.GetParamAsString("internals"), shapes);
|
||||
internals.resize(shapes.size());
|
||||
for (int i = 0; i < shapes.size(); ++i)
|
||||
internals[i].create(std::vector<int>(shapes[i].begin(), shapes[i].end()), CV_32F);
|
||||
}
|
||||
|
||||
virtual InferenceEngine::StatusCode execute(std::vector<InferenceEngine::Blob::Ptr>& inputs,
|
||||
std::vector<InferenceEngine::Blob::Ptr>& outputs,
|
||||
InferenceEngine::ResponseDesc *resp) noexcept
|
||||
{
|
||||
std::vector<Mat> inpMats, outMats;
|
||||
infEngineBlobsToMats(inputs, inpMats);
|
||||
infEngineBlobsToMats(outputs, outMats);
|
||||
|
||||
try
|
||||
{
|
||||
cvLayer->forward(inpMats, outMats, internals);
|
||||
return InferenceEngine::StatusCode::OK;
|
||||
}
|
||||
catch (...)
|
||||
{
|
||||
return InferenceEngine::StatusCode::GENERAL_ERROR;
|
||||
}
|
||||
}
|
||||
|
||||
virtual InferenceEngine::StatusCode
|
||||
getSupportedConfigurations(std::vector<InferenceEngine::LayerConfig>& conf,
|
||||
InferenceEngine::ResponseDesc* resp) noexcept
|
||||
{
|
||||
std::vector<InferenceEngine::DataConfig> inDataConfig;
|
||||
std::vector<InferenceEngine::DataConfig> outDataConfig;
|
||||
for (auto& it : cnnLayer.insData)
|
||||
{
|
||||
InferenceEngine::DataConfig conf;
|
||||
conf.desc = it.lock()->getTensorDesc();
|
||||
inDataConfig.push_back(conf);
|
||||
}
|
||||
|
||||
for (auto& it : cnnLayer.outData)
|
||||
{
|
||||
InferenceEngine::DataConfig conf;
|
||||
conf.desc = it->getTensorDesc();
|
||||
outDataConfig.push_back(conf);
|
||||
}
|
||||
|
||||
InferenceEngine::LayerConfig layerConfig;
|
||||
layerConfig.inConfs = inDataConfig;
|
||||
layerConfig.outConfs = outDataConfig;
|
||||
|
||||
conf.push_back(layerConfig);
|
||||
return InferenceEngine::StatusCode::OK;
|
||||
}
|
||||
|
||||
InferenceEngine::StatusCode init(InferenceEngine::LayerConfig& config,
|
||||
InferenceEngine::ResponseDesc *resp) noexcept
|
||||
{
|
||||
return InferenceEngine::StatusCode::OK;
|
||||
}
|
||||
|
||||
private:
|
||||
InferenceEngine::CNNLayer cnnLayer;
|
||||
dnn::Layer* cvLayer;
|
||||
std::vector<Mat> internals;
|
||||
};
|
||||
|
||||
class InfEngineCustomLayerShapeInfer : public InferenceEngine::IShapeInferImpl
|
||||
{
|
||||
public:
|
||||
InferenceEngine::StatusCode
|
||||
inferShapes(const std::vector<InferenceEngine::Blob::CPtr>& inBlobs,
|
||||
const std::map<std::string, std::string>& params,
|
||||
const std::map<std::string, InferenceEngine::Blob::Ptr>& blobs,
|
||||
std::vector<InferenceEngine::SizeVector>& outShapes,
|
||||
InferenceEngine::ResponseDesc* desc) noexcept override
|
||||
{
|
||||
strToShapes(params.at("outputs"), outShapes);
|
||||
return InferenceEngine::StatusCode::OK;
|
||||
}
|
||||
};
|
||||
|
||||
class InfEngineCustomLayerFactory : public InferenceEngine::ILayerImplFactory {
|
||||
public:
|
||||
explicit InfEngineCustomLayerFactory(const InferenceEngine::CNNLayer* layer) : cnnLayer(*layer) {}
|
||||
|
||||
InferenceEngine::StatusCode
|
||||
getImplementations(std::vector<InferenceEngine::ILayerImpl::Ptr>& impls,
|
||||
InferenceEngine::ResponseDesc* resp) noexcept override {
|
||||
impls.push_back(std::make_shared<InfEngineCustomLayer>(cnnLayer));
|
||||
return InferenceEngine::StatusCode::OK;
|
||||
}
|
||||
|
||||
private:
|
||||
InferenceEngine::CNNLayer cnnLayer;
|
||||
};
|
||||
|
||||
class InfEngineExtension : public InferenceEngine::IExtension
|
||||
{
|
||||
public:
|
||||
virtual void SetLogCallback(InferenceEngine::IErrorListener&) noexcept {}
|
||||
virtual void Unload() noexcept {}
|
||||
virtual void Release() noexcept {}
|
||||
virtual void GetVersion(const InferenceEngine::Version*&) const noexcept {}
|
||||
|
||||
virtual InferenceEngine::StatusCode getPrimitiveTypes(char**&, unsigned int&,
|
||||
InferenceEngine::ResponseDesc*) noexcept
|
||||
{
|
||||
return InferenceEngine::StatusCode::OK;
|
||||
}
|
||||
|
||||
InferenceEngine::StatusCode getFactoryFor(InferenceEngine::ILayerImplFactory*& factory,
|
||||
const InferenceEngine::CNNLayer* cnnLayer,
|
||||
InferenceEngine::ResponseDesc* resp) noexcept
|
||||
{
|
||||
if (cnnLayer->type != kOpenCVLayersType)
|
||||
return InferenceEngine::StatusCode::NOT_IMPLEMENTED;
|
||||
factory = new InfEngineCustomLayerFactory(cnnLayer);
|
||||
return InferenceEngine::StatusCode::OK;
|
||||
}
|
||||
};
|
||||
|
||||
InfEngineBackendNode::InfEngineBackendNode(const InferenceEngine::Builder::Layer& _layer)
|
||||
: BackendNode(DNN_BACKEND_INFERENCE_ENGINE), layer(_layer) {}
|
||||
|
||||
InfEngineBackendNode::InfEngineBackendNode(Ptr<Layer>& cvLayer_, std::vector<Mat*>& inputs,
|
||||
std::vector<Mat>& outputs,
|
||||
std::vector<Mat>& internals)
|
||||
: BackendNode(DNN_BACKEND_INFERENCE_ENGINE), layer(cvLayer_->name),
|
||||
cvLayer(cvLayer_)
|
||||
{
|
||||
CV_Assert(!cvLayer->name.empty());
|
||||
layer.setName(cvLayer->name);
|
||||
layer.setType(kOpenCVLayersType);
|
||||
layer.getParameters()["impl"] = (size_t)cvLayer.get();
|
||||
layer.getParameters()["outputs"] = shapesToStr(outputs);
|
||||
layer.getParameters()["internals"] = shapesToStr(internals);
|
||||
layer.setInputPorts(std::vector<InferenceEngine::Port>(inputs.size()));
|
||||
layer.setOutputPorts(std::vector<InferenceEngine::Port>(outputs.size()));
|
||||
}
|
||||
|
||||
static std::vector<Ptr<InfEngineBackendWrapper> >
|
||||
infEngineWrappers(const std::vector<Ptr<BackendWrapper> >& ptrs)
|
||||
{
|
||||
@ -111,6 +287,8 @@ void InfEngineBackendNet::init(int targetId)
|
||||
#endif
|
||||
netBuilder.addLayer({InferenceEngine::PortInfo(id)}, outLayer);
|
||||
}
|
||||
netBuilder.getContext().addShapeInferImpl(kOpenCVLayersType,
|
||||
std::make_shared<InfEngineCustomLayerShapeInfer>());
|
||||
cnn = InferenceEngine::CNNNetwork(InferenceEngine::Builder::convertToICNNNetwork(netBuilder.build()));
|
||||
}
|
||||
|
||||
@ -404,6 +582,7 @@ void InfEngineBackendNet::initPlugin(InferenceEngine::CNNNetwork& net)
|
||||
try
|
||||
{
|
||||
AutoLock lock(getInitializationMutex());
|
||||
InferenceEngine::Core& ie = getCore();
|
||||
#if INF_ENGINE_VER_MAJOR_LE(INF_ENGINE_RELEASE_2019R1)
|
||||
auto& sharedPlugins = getSharedPlugins();
|
||||
auto pluginIt = sharedPlugins.find(device_name);
|
||||
@ -465,7 +644,9 @@ void InfEngineBackendNet::initPlugin(InferenceEngine::CNNNetwork& net)
|
||||
#if INF_ENGINE_VER_MAJOR_LE(INF_ENGINE_RELEASE_2019R1)
|
||||
enginePtr->AddExtension(extension, 0);
|
||||
#else
|
||||
getCore().AddExtension(extension, "CPU");
|
||||
ie.AddExtension(extension, "CPU");
|
||||
// OpenCV fallbacks as extensions.
|
||||
ie.AddExtension(std::make_shared<InfEngineExtension>(), "CPU");
|
||||
#endif
|
||||
CV_LOG_INFO(NULL, "DNN-IE: Loaded extension plugin: " << libName);
|
||||
found = true;
|
||||
@ -486,7 +667,7 @@ void InfEngineBackendNet::initPlugin(InferenceEngine::CNNNetwork& net)
|
||||
}}, 0);
|
||||
#else
|
||||
if (device_name == "CPU")
|
||||
getCore().SetConfig({{
|
||||
ie.SetConfig({{
|
||||
InferenceEngine::PluginConfigParams::KEY_CPU_THREADS_NUM, format("%d", getNumThreads()),
|
||||
}}, device_name);
|
||||
#endif
|
||||
@ -496,7 +677,25 @@ void InfEngineBackendNet::initPlugin(InferenceEngine::CNNNetwork& net)
|
||||
plugin = InferenceEngine::InferencePlugin(enginePtr);
|
||||
netExec = plugin.LoadNetwork(net, {});
|
||||
#else
|
||||
netExec = getCore().LoadNetwork(net, device_name);
|
||||
bool isHetero = false;
|
||||
if (device_name != "CPU")
|
||||
{
|
||||
isHetero = device_name == "FPGA";
|
||||
for (auto& layer : net)
|
||||
{
|
||||
if (layer->type == kOpenCVLayersType)
|
||||
{
|
||||
layer->affinity = "CPU";
|
||||
isHetero = true;
|
||||
}
|
||||
else
|
||||
layer->affinity = device_name;
|
||||
}
|
||||
}
|
||||
if (isHetero)
|
||||
netExec = ie.LoadNetwork(net, "HETERO:" + device_name + ",CPU");
|
||||
else
|
||||
netExec = ie.LoadNetwork(net, device_name);
|
||||
#endif
|
||||
}
|
||||
catch (const std::exception& ex)
|
||||
@ -673,6 +872,14 @@ Mat infEngineBlobToMat(const InferenceEngine::Blob::Ptr& blob)
|
||||
return Mat(size, type, (void*)blob->buffer());
|
||||
}
|
||||
|
||||
void infEngineBlobsToMats(const std::vector<InferenceEngine::Blob::Ptr>& blobs,
|
||||
std::vector<Mat>& mats)
|
||||
{
|
||||
mats.resize(blobs.size());
|
||||
for (int i = 0; i < blobs.size(); ++i)
|
||||
mats[i] = infEngineBlobToMat(blobs[i]);
|
||||
}
|
||||
|
||||
bool InfEngineBackendLayer::getMemoryShapes(const std::vector<MatShape> &inputs,
|
||||
const int requiredOutputs,
|
||||
std::vector<MatShape> &outputs,
|
||||
@ -770,7 +977,8 @@ void resetMyriadDevice()
|
||||
#if INF_ENGINE_VER_MAJOR_LE(INF_ENGINE_RELEASE_2019R1)
|
||||
getSharedPlugins().erase("MYRIAD");
|
||||
#else
|
||||
getCore().UnregisterPlugin("MYRIAD");
|
||||
// To unregister both "MYRIAD" and "HETERO:MYRIAD,CPU" plugins
|
||||
getCore() = InferenceEngine::Core();
|
||||
#endif
|
||||
#endif // HAVE_INF_ENGINE
|
||||
}
|
||||
|
||||
@ -137,12 +137,17 @@ class InfEngineBackendNode : public BackendNode
|
||||
public:
|
||||
InfEngineBackendNode(const InferenceEngine::Builder::Layer& layer);
|
||||
|
||||
InfEngineBackendNode(Ptr<Layer>& layer, std::vector<Mat*>& inputs,
|
||||
std::vector<Mat>& outputs, std::vector<Mat>& internals);
|
||||
|
||||
void connect(std::vector<Ptr<BackendWrapper> >& inputs,
|
||||
std::vector<Ptr<BackendWrapper> >& outputs);
|
||||
|
||||
// Inference Engine network object that allows to obtain the outputs of this layer.
|
||||
InferenceEngine::Builder::Layer layer;
|
||||
Ptr<InfEngineBackendNet> net;
|
||||
// CPU fallback in case of unsupported Inference Engine layer.
|
||||
Ptr<dnn::Layer> cvLayer;
|
||||
};
|
||||
|
||||
class InfEngineBackendWrapper : public BackendWrapper
|
||||
@ -173,6 +178,9 @@ InferenceEngine::DataPtr infEngineDataNode(const Ptr<BackendWrapper>& ptr);
|
||||
|
||||
Mat infEngineBlobToMat(const InferenceEngine::Blob::Ptr& blob);
|
||||
|
||||
void infEngineBlobsToMats(const std::vector<InferenceEngine::Blob::Ptr>& blobs,
|
||||
std::vector<Mat>& mats);
|
||||
|
||||
// Convert Inference Engine blob with FP32 precision to FP16 precision.
|
||||
// Allocates memory for a new blob.
|
||||
InferenceEngine::Blob::Ptr convertFp16(const InferenceEngine::Blob::Ptr& blob);
|
||||
|
||||
@ -53,17 +53,6 @@ static std::string _tf(TString filename)
|
||||
return (getOpenCVExtraDir() + "/dnn/") + filename;
|
||||
}
|
||||
|
||||
static std::vector<String> getOutputsNames(const Net& net)
|
||||
{
|
||||
std::vector<String> names;
|
||||
std::vector<int> outLayers = net.getUnconnectedOutLayers();
|
||||
std::vector<String> layersNames = net.getLayerNames();
|
||||
names.resize(outLayers.size());
|
||||
for (size_t i = 0; i < outLayers.size(); ++i)
|
||||
names[i] = layersNames[outLayers[i] - 1];
|
||||
return names;
|
||||
}
|
||||
|
||||
TEST(Test_Darknet, read_tiny_yolo_voc)
|
||||
{
|
||||
Net net = readNetFromDarknet(_tf("tiny-yolo-voc.cfg"));
|
||||
@ -159,7 +148,7 @@ public:
|
||||
net.setPreferableTarget(target);
|
||||
net.setInput(inp);
|
||||
std::vector<Mat> outs;
|
||||
net.forward(outs, getOutputsNames(net));
|
||||
net.forward(outs, net.getUnconnectedOutLayersNames());
|
||||
|
||||
for (int b = 0; b < batch_size; ++b)
|
||||
{
|
||||
@ -339,6 +328,62 @@ TEST_P(Test_Darknet_nets, TinyYoloVoc)
|
||||
}
|
||||
}
|
||||
|
||||
#ifdef HAVE_INF_ENGINE
|
||||
static const std::chrono::milliseconds async_timeout(500);
|
||||
|
||||
typedef testing::TestWithParam<tuple<std::string, Target> > Test_Darknet_nets_async;
|
||||
TEST_P(Test_Darknet_nets_async, Accuracy)
|
||||
{
|
||||
applyTestTag(CV_TEST_TAG_MEMORY_512MB);
|
||||
|
||||
std::string prefix = get<0>(GetParam());
|
||||
int target = get<1>(GetParam());
|
||||
|
||||
const int numInputs = 2;
|
||||
std::vector<Mat> inputs(numInputs);
|
||||
int blobSize[] = {1, 3, 416, 416};
|
||||
for (int i = 0; i < numInputs; ++i)
|
||||
{
|
||||
inputs[i].create(4, &blobSize[0], CV_32F);
|
||||
randu(inputs[i], 0, 1);
|
||||
}
|
||||
|
||||
Net netSync = readNet(findDataFile("dnn/" + prefix + ".cfg"),
|
||||
findDataFile("dnn/" + prefix + ".weights", false));
|
||||
netSync.setPreferableTarget(target);
|
||||
|
||||
// Run synchronously.
|
||||
std::vector<Mat> refs(numInputs);
|
||||
for (int i = 0; i < numInputs; ++i)
|
||||
{
|
||||
netSync.setInput(inputs[i]);
|
||||
refs[i] = netSync.forward().clone();
|
||||
}
|
||||
|
||||
Net netAsync = readNet(findDataFile("dnn/" + prefix + ".cfg"),
|
||||
findDataFile("dnn/" + prefix + ".weights", false));
|
||||
netAsync.setPreferableTarget(target);
|
||||
|
||||
// Run asynchronously. To make test more robust, process inputs in the reversed order.
|
||||
for (int i = numInputs - 1; i >= 0; --i)
|
||||
{
|
||||
netAsync.setInput(inputs[i]);
|
||||
|
||||
AsyncArray out = netAsync.forwardAsync();
|
||||
ASSERT_TRUE(out.valid());
|
||||
Mat result;
|
||||
EXPECT_TRUE(out.get(result, async_timeout));
|
||||
normAssert(refs[i], result, format("Index: %d", i).c_str(), 0, 0);
|
||||
}
|
||||
}
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(/**/, Test_Darknet_nets_async, Combine(
|
||||
Values("yolo-voc", "tiny-yolo-voc", "yolov3"),
|
||||
ValuesIn(getAvailableTargets(DNN_BACKEND_INFERENCE_ENGINE))
|
||||
));
|
||||
|
||||
#endif
|
||||
|
||||
TEST_P(Test_Darknet_nets, YOLOv3)
|
||||
{
|
||||
applyTestTag(CV_TEST_TAG_LONG, (target == DNN_TARGET_CPU ? CV_TEST_TAG_MEMORY_1GB : CV_TEST_TAG_MEMORY_2GB));
|
||||
@ -376,6 +421,16 @@ TEST_P(Test_Darknet_nets, YOLOv3)
|
||||
applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_OPENCL) // Test with 'batch size 2' is disabled for DLIE/OpenCL target
|
||||
#endif
|
||||
|
||||
#if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_EQ(2019020000)
|
||||
if (backend == DNN_BACKEND_INFERENCE_ENGINE)
|
||||
{
|
||||
if (target == DNN_TARGET_OPENCL)
|
||||
applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_OPENCL, CV_TEST_TAG_DNN_SKIP_IE_2019R2);
|
||||
if (target == DNN_TARGET_OPENCL_FP16)
|
||||
applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_OPENCL_FP16, CV_TEST_TAG_DNN_SKIP_IE_2019R2);
|
||||
}
|
||||
#endif
|
||||
|
||||
{
|
||||
SCOPED_TRACE("batch size 2");
|
||||
testDarknetModel(config_file, weights_file, ref, scoreDiff, iouDiff);
|
||||
|
||||
@ -554,6 +554,11 @@ TEST_P(ReLU, Accuracy)
|
||||
Backend backendId = get<0>(get<1>(GetParam()));
|
||||
Target targetId = get<1>(get<1>(GetParam()));
|
||||
|
||||
#if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_EQ(2019020000)
|
||||
if (backendId == DNN_BACKEND_INFERENCE_ENGINE && targetId == DNN_TARGET_MYRIAD && negativeSlope < 0)
|
||||
applyTestTag(CV_TEST_TAG_DNN_SKIP_IE, CV_TEST_TAG_DNN_SKIP_IE_2019R2);
|
||||
#endif
|
||||
|
||||
LayerParams lp;
|
||||
lp.set("negative_slope", negativeSlope);
|
||||
lp.type = "ReLU";
|
||||
|
||||
@ -1112,7 +1112,7 @@ INSTANTIATE_TEST_CASE_P(/*nothing*/, Test_DLDT_two_inputs, Combine(
|
||||
class UnsupportedLayer : public Layer
|
||||
{
|
||||
public:
|
||||
UnsupportedLayer(const LayerParams ¶ms) {}
|
||||
UnsupportedLayer(const LayerParams ¶ms) : Layer(params) {}
|
||||
|
||||
static Ptr<Layer> create(const LayerParams& params)
|
||||
{
|
||||
|
||||
@ -145,8 +145,17 @@ TEST_P(Test_TensorFlow_layers, padding)
|
||||
{
|
||||
runTensorFlowNet("padding_valid");
|
||||
runTensorFlowNet("spatial_padding");
|
||||
runTensorFlowNet("keras_pad_concat");
|
||||
runTensorFlowNet("mirror_pad");
|
||||
#if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_EQ(2019020000)
|
||||
if (backend == DNN_BACKEND_INFERENCE_ENGINE)
|
||||
{
|
||||
if (target == DNN_TARGET_MYRIAD)
|
||||
applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_2019R2);
|
||||
if (target == DNN_TARGET_OPENCL_FP16)
|
||||
applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_OPENCL_FP16, CV_TEST_TAG_DNN_SKIP_IE_2019R2);
|
||||
}
|
||||
#endif
|
||||
runTensorFlowNet("keras_pad_concat");
|
||||
}
|
||||
|
||||
TEST_P(Test_TensorFlow_layers, padding_same)
|
||||
@ -472,7 +481,7 @@ TEST_P(Test_TensorFlow_nets, Faster_RCNN)
|
||||
"faster_rcnn_resnet50_coco_2018_01_28"};
|
||||
|
||||
checkBackend();
|
||||
if (backend == DNN_BACKEND_INFERENCE_ENGINE)
|
||||
if (backend == DNN_BACKEND_INFERENCE_ENGINE && target != DNN_TARGET_CPU)
|
||||
applyTestTag(CV_TEST_TAG_DNN_SKIP_IE);
|
||||
if (backend == DNN_BACKEND_OPENCV && target == DNN_TARGET_OPENCL_FP16)
|
||||
applyTestTag(CV_TEST_TAG_DNN_SKIP_OPENCL_FP16);
|
||||
@ -573,6 +582,10 @@ TEST_P(Test_TensorFlow_nets, EAST_text_detection)
|
||||
#if defined(INF_ENGINE_RELEASE)
|
||||
if (backend == DNN_BACKEND_INFERENCE_ENGINE && target == DNN_TARGET_MYRIAD)
|
||||
applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD);
|
||||
|
||||
if (backend == DNN_BACKEND_INFERENCE_ENGINE && target == DNN_TARGET_OPENCL_FP16 &&
|
||||
INF_ENGINE_VER_MAJOR_EQ(2019020000))
|
||||
applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_OPENCL_FP16, CV_TEST_TAG_DNN_SKIP_IE_2019R2);
|
||||
#endif
|
||||
|
||||
checkBackend();
|
||||
@ -673,7 +686,8 @@ TEST_P(Test_TensorFlow_layers, lstm)
|
||||
|
||||
TEST_P(Test_TensorFlow_layers, split)
|
||||
{
|
||||
if (backend == DNN_BACKEND_INFERENCE_ENGINE)
|
||||
if (backend == DNN_BACKEND_INFERENCE_ENGINE && target == DNN_TARGET_MYRIAD &&
|
||||
getInferenceEngineVPUType() == CV_DNN_INFERENCE_ENGINE_VPU_TYPE_MYRIAD_2)
|
||||
applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD_2);
|
||||
runTensorFlowNet("split");
|
||||
if (backend == DNN_BACKEND_INFERENCE_ENGINE)
|
||||
|
||||
@ -80,6 +80,10 @@ This section describes approaches based on local 2D features and used to categor
|
||||
- (Python) An example using the features2D framework to perform object categorization can be
|
||||
found at opencv_source_code/samples/python/find_obj.py
|
||||
|
||||
@defgroup feature2d_hal Hardware Acceleration Layer
|
||||
@{
|
||||
@defgroup features2d_hal_interface Interface
|
||||
@}
|
||||
@}
|
||||
*/
|
||||
|
||||
|
||||
@ -2,7 +2,7 @@
|
||||
#define OPENCV_FEATURE2D_HAL_INTERFACE_H
|
||||
|
||||
#include "opencv2/core/cvdef.h"
|
||||
//! @addtogroup featrure2d_hal_interface
|
||||
//! @addtogroup features2d_hal_interface
|
||||
//! @{
|
||||
|
||||
//! @name Fast feature detector types
|
||||
|
||||
@ -107,38 +107,38 @@ the index is built.
|
||||
`Distance` functor specifies the metric to be used to calculate the distance between two points.
|
||||
There are several `Distance` functors that are readily available:
|
||||
|
||||
@link cvflann::L2_Simple cv::flann::L2_Simple @endlink- Squared Euclidean distance functor.
|
||||
cv::cvflann::L2_Simple - Squared Euclidean distance functor.
|
||||
This is the simpler, unrolled version. This is preferable for very low dimensionality data (eg 3D points)
|
||||
|
||||
@link cvflann::L2 cv::flann::L2 @endlink- Squared Euclidean distance functor, optimized version.
|
||||
cv::flann::L2 - Squared Euclidean distance functor, optimized version.
|
||||
|
||||
@link cvflann::L1 cv::flann::L1 @endlink - Manhattan distance functor, optimized version.
|
||||
cv::flann::L1 - Manhattan distance functor, optimized version.
|
||||
|
||||
@link cvflann::MinkowskiDistance cv::flann::MinkowskiDistance @endlink - The Minkowsky distance functor.
|
||||
cv::flann::MinkowskiDistance - The Minkowsky distance functor.
|
||||
This is highly optimised with loop unrolling.
|
||||
The computation of squared root at the end is omitted for efficiency.
|
||||
|
||||
@link cvflann::MaxDistance cv::flann::MaxDistance @endlink - The max distance functor. It computes the
|
||||
cv::flann::MaxDistance - The max distance functor. It computes the
|
||||
maximum distance between two vectors. This distance is not a valid kdtree distance, it's not
|
||||
dimensionwise additive.
|
||||
|
||||
@link cvflann::HammingLUT cv::flann::HammingLUT @endlink - %Hamming distance functor. It counts the bit
|
||||
cv::flann::HammingLUT - %Hamming distance functor. It counts the bit
|
||||
differences between two strings using a lookup table implementation.
|
||||
|
||||
@link cvflann::Hamming cv::flann::Hamming @endlink - %Hamming distance functor. Population count is
|
||||
cv::flann::Hamming - %Hamming distance functor. Population count is
|
||||
performed using library calls, if available. Lookup table implementation is used as a fallback.
|
||||
|
||||
@link cvflann::Hamming2 cv::flann::Hamming2 @endlink- %Hamming distance functor. Population count is
|
||||
cv::flann::Hamming2 - %Hamming distance functor. Population count is
|
||||
implemented in 12 arithmetic operations (one of which is multiplication).
|
||||
|
||||
@link cvflann::HistIntersectionDistance cv::flann::HistIntersectionDistance @endlink - The histogram
|
||||
cv::flann::HistIntersectionDistance - The histogram
|
||||
intersection distance functor.
|
||||
|
||||
@link cvflann::HellingerDistance cv::flann::HellingerDistance @endlink - The Hellinger distance functor.
|
||||
cv::flann::HellingerDistance - The Hellinger distance functor.
|
||||
|
||||
@link cvflann::ChiSquareDistance cv::flann::ChiSquareDistance @endlink - The chi-square distance functor.
|
||||
cv::flann::ChiSquareDistance - The chi-square distance functor.
|
||||
|
||||
@link cvflann::KL_Divergence cv::flann::KL_Divergence @endlink - The Kullback-Leibler divergence functor.
|
||||
cv::flann::KL_Divergence - The Kullback-Leibler divergence functor.
|
||||
|
||||
Although the provided implementations cover a vast range of cases, it is also possible to use
|
||||
a custom implementation. The distance functor is a class whose `operator()` computes the distance
|
||||
@ -397,8 +397,6 @@ int GenericIndex<Distance>::radiusSearch(const Mat& query, Mat& indices, Mat& di
|
||||
return nnIndex->radiusSearch(m_query,m_indices,m_dists,radius,searchParams);
|
||||
}
|
||||
|
||||
//! @endcond
|
||||
|
||||
/**
|
||||
* @deprecated Use GenericIndex class instead
|
||||
*/
|
||||
@ -531,6 +529,7 @@ private:
|
||||
::cvflann::Index< L1<ElementType> >* nnIndex_L1;
|
||||
};
|
||||
|
||||
//! @endcond
|
||||
|
||||
/** @brief Clusters features using hierarchical k-means algorithm.
|
||||
|
||||
@ -567,8 +566,8 @@ int hierarchicalClustering(const Mat& features, Mat& centers, const ::cvflann::K
|
||||
return ::cvflann::hierarchicalClustering<Distance>(m_features, m_centers, params, d);
|
||||
}
|
||||
|
||||
/** @deprecated
|
||||
*/
|
||||
//! @cond IGNORED
|
||||
|
||||
template <typename ELEM_TYPE, typename DIST_TYPE>
|
||||
CV_DEPRECATED int hierarchicalClustering(const Mat& features, Mat& centers, const ::cvflann::KMeansIndexParams& params)
|
||||
{
|
||||
@ -589,6 +588,8 @@ CV_DEPRECATED int hierarchicalClustering(const Mat& features, Mat& centers, cons
|
||||
}
|
||||
}
|
||||
|
||||
//! @endcond
|
||||
|
||||
//! @} flann
|
||||
|
||||
} } // namespace cv::flann
|
||||
|
||||
@ -30,6 +30,8 @@
|
||||
#ifndef OPENCV_FLANN_ALL_INDICES_H_
|
||||
#define OPENCV_FLANN_ALL_INDICES_H_
|
||||
|
||||
//! @cond IGNORED
|
||||
|
||||
#include "general.h"
|
||||
|
||||
#include "nn_index.h"
|
||||
@ -152,4 +154,6 @@ NNIndex<Distance>* create_index_by_type(const Matrix<typename Distance::ElementT
|
||||
|
||||
}
|
||||
|
||||
//! @endcond
|
||||
|
||||
#endif /* OPENCV_FLANN_ALL_INDICES_H_ */
|
||||
|
||||
@ -31,6 +31,8 @@
|
||||
#ifndef OPENCV_FLANN_ALLOCATOR_H_
|
||||
#define OPENCV_FLANN_ALLOCATOR_H_
|
||||
|
||||
//! @cond IGNORED
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
|
||||
@ -189,4 +191,6 @@ private:
|
||||
|
||||
}
|
||||
|
||||
//! @endcond
|
||||
|
||||
#endif //OPENCV_FLANN_ALLOCATOR_H_
|
||||
|
||||
@ -12,6 +12,8 @@
|
||||
* Adapted for FLANN by Marius Muja
|
||||
*/
|
||||
|
||||
//! @cond IGNORED
|
||||
|
||||
#include "defines.h"
|
||||
#include <stdexcept>
|
||||
#include <ostream>
|
||||
@ -327,4 +329,6 @@ inline std::ostream& operator <<(std::ostream& out, const any& any_val)
|
||||
|
||||
}
|
||||
|
||||
//! @endcond
|
||||
|
||||
#endif // OPENCV_FLANN_ANY_H_
|
||||
|
||||
@ -30,6 +30,8 @@
|
||||
#ifndef OPENCV_FLANN_AUTOTUNED_INDEX_H_
|
||||
#define OPENCV_FLANN_AUTOTUNED_INDEX_H_
|
||||
|
||||
//! @cond IGNORED
|
||||
|
||||
#include <sstream>
|
||||
|
||||
#include "general.h"
|
||||
@ -588,4 +590,6 @@ private:
|
||||
};
|
||||
}
|
||||
|
||||
//! @endcond
|
||||
|
||||
#endif /* OPENCV_FLANN_AUTOTUNED_INDEX_H_ */
|
||||
|
||||
@ -31,6 +31,8 @@
|
||||
#ifndef OPENCV_FLANN_COMPOSITE_INDEX_H_
|
||||
#define OPENCV_FLANN_COMPOSITE_INDEX_H_
|
||||
|
||||
//! @cond IGNORED
|
||||
|
||||
#include "general.h"
|
||||
#include "nn_index.h"
|
||||
#include "kdtree_index.h"
|
||||
@ -191,4 +193,6 @@ private:
|
||||
|
||||
}
|
||||
|
||||
//! @endcond
|
||||
|
||||
#endif //OPENCV_FLANN_COMPOSITE_INDEX_H_
|
||||
|
||||
@ -30,9 +30,13 @@
|
||||
#ifndef OPENCV_FLANN_CONFIG_H_
|
||||
#define OPENCV_FLANN_CONFIG_H_
|
||||
|
||||
//! @cond IGNORED
|
||||
|
||||
#ifdef FLANN_VERSION_
|
||||
#undef FLANN_VERSION_
|
||||
#endif
|
||||
#define FLANN_VERSION_ "1.6.10"
|
||||
|
||||
//! @endcond
|
||||
|
||||
#endif /* OPENCV_FLANN_CONFIG_H_ */
|
||||
|
||||
@ -30,6 +30,8 @@
|
||||
#ifndef OPENCV_FLANN_DEFINES_H_
|
||||
#define OPENCV_FLANN_DEFINES_H_
|
||||
|
||||
//! @cond IGNORED
|
||||
|
||||
#include "config.h"
|
||||
|
||||
#ifdef FLANN_EXPORT
|
||||
@ -161,4 +163,6 @@ enum
|
||||
|
||||
}
|
||||
|
||||
//! @endcond
|
||||
|
||||
#endif /* OPENCV_FLANN_DEFINES_H_ */
|
||||
|
||||
@ -31,6 +31,8 @@
|
||||
#ifndef OPENCV_FLANN_DIST_H_
|
||||
#define OPENCV_FLANN_DIST_H_
|
||||
|
||||
//! @cond IGNORED
|
||||
|
||||
#include <cmath>
|
||||
#include <cstdlib>
|
||||
#include <string.h>
|
||||
@ -901,4 +903,6 @@ typename Distance::ResultType ensureSimpleDistance( typename Distance::ResultTyp
|
||||
|
||||
}
|
||||
|
||||
//! @endcond
|
||||
|
||||
#endif //OPENCV_FLANN_DIST_H_
|
||||
|
||||
@ -2,6 +2,8 @@
|
||||
#ifndef OPENCV_FLANN_DUMMY_H_
|
||||
#define OPENCV_FLANN_DUMMY_H_
|
||||
|
||||
//! @cond IGNORED
|
||||
|
||||
namespace cvflann
|
||||
{
|
||||
|
||||
@ -9,5 +11,6 @@ CV_DEPRECATED inline void dummyfunc() {}
|
||||
|
||||
}
|
||||
|
||||
//! @endcond
|
||||
|
||||
#endif /* OPENCV_FLANN_DUMMY_H_ */
|
||||
|
||||
@ -35,6 +35,8 @@
|
||||
#ifndef OPENCV_FLANN_DYNAMIC_BITSET_H_
|
||||
#define OPENCV_FLANN_DYNAMIC_BITSET_H_
|
||||
|
||||
//! @cond IGNORED
|
||||
|
||||
#ifndef FLANN_USE_BOOST
|
||||
# define FLANN_USE_BOOST 0
|
||||
#endif
|
||||
@ -156,4 +158,6 @@ private:
|
||||
|
||||
#endif
|
||||
|
||||
//! @endcond
|
||||
|
||||
#endif // OPENCV_FLANN_DYNAMIC_BITSET_H_
|
||||
|
||||
@ -31,6 +31,8 @@
|
||||
#ifndef OPENCV_FLANN_BASE_HPP_
|
||||
#define OPENCV_FLANN_BASE_HPP_
|
||||
|
||||
//! @cond IGNORED
|
||||
|
||||
#include <vector>
|
||||
#include <cassert>
|
||||
#include <cstdio>
|
||||
@ -292,4 +294,7 @@ int hierarchicalClustering(const Matrix<typename Distance::ElementType>& points,
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
//! @endcond
|
||||
|
||||
#endif /* OPENCV_FLANN_BASE_HPP_ */
|
||||
|
||||
@ -31,6 +31,8 @@
|
||||
#ifndef OPENCV_FLANN_GENERAL_H_
|
||||
#define OPENCV_FLANN_GENERAL_H_
|
||||
|
||||
//! @cond IGNORED
|
||||
|
||||
#include "opencv2/core.hpp"
|
||||
|
||||
namespace cvflann
|
||||
@ -46,5 +48,6 @@ public:
|
||||
|
||||
}
|
||||
|
||||
//! @endcond
|
||||
|
||||
#endif /* OPENCV_FLANN_GENERAL_H_ */
|
||||
|
||||
@ -31,6 +31,8 @@
|
||||
#ifndef OPENCV_FLANN_GROUND_TRUTH_H_
|
||||
#define OPENCV_FLANN_GROUND_TRUTH_H_
|
||||
|
||||
//! @cond IGNORED
|
||||
|
||||
#include "dist.h"
|
||||
#include "matrix.h"
|
||||
|
||||
@ -91,4 +93,6 @@ void compute_ground_truth(const Matrix<typename Distance::ElementType>& dataset,
|
||||
|
||||
}
|
||||
|
||||
//! @endcond
|
||||
|
||||
#endif //OPENCV_FLANN_GROUND_TRUTH_H_
|
||||
|
||||
235
modules/flann/include/opencv2/flann/hdf5.h
Normal file
235
modules/flann/include/opencv2/flann/hdf5.h
Normal file
@ -0,0 +1,235 @@
|
||||
/***********************************************************************
|
||||
* Software License Agreement (BSD License)
|
||||
*
|
||||
* Copyright 2008-2009 Marius Muja (mariusm@cs.ubc.ca). All rights reserved.
|
||||
* Copyright 2008-2009 David G. Lowe (lowe@cs.ubc.ca). All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
*
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
|
||||
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
||||
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
|
||||
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
|
||||
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
||||
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
||||
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*************************************************************************/
|
||||
|
||||
|
||||
#ifndef OPENCV_FLANN_HDF5_H_
|
||||
#define OPENCV_FLANN_HDF5_H_
|
||||
|
||||
//! @cond IGNORED
|
||||
|
||||
#include <hdf5.h>
|
||||
|
||||
#include "matrix.h"
|
||||
|
||||
|
||||
namespace cvflann
|
||||
{
|
||||
|
||||
namespace
|
||||
{
|
||||
|
||||
template<typename T>
|
||||
hid_t get_hdf5_type()
|
||||
{
|
||||
throw FLANNException("Unsupported type for IO operations");
|
||||
}
|
||||
|
||||
template<>
|
||||
hid_t get_hdf5_type<char>() { return H5T_NATIVE_CHAR; }
|
||||
template<>
|
||||
hid_t get_hdf5_type<unsigned char>() { return H5T_NATIVE_UCHAR; }
|
||||
template<>
|
||||
hid_t get_hdf5_type<short int>() { return H5T_NATIVE_SHORT; }
|
||||
template<>
|
||||
hid_t get_hdf5_type<unsigned short int>() { return H5T_NATIVE_USHORT; }
|
||||
template<>
|
||||
hid_t get_hdf5_type<int>() { return H5T_NATIVE_INT; }
|
||||
template<>
|
||||
hid_t get_hdf5_type<unsigned int>() { return H5T_NATIVE_UINT; }
|
||||
template<>
|
||||
hid_t get_hdf5_type<long>() { return H5T_NATIVE_LONG; }
|
||||
template<>
|
||||
hid_t get_hdf5_type<unsigned long>() { return H5T_NATIVE_ULONG; }
|
||||
template<>
|
||||
hid_t get_hdf5_type<float>() { return H5T_NATIVE_FLOAT; }
|
||||
template<>
|
||||
hid_t get_hdf5_type<double>() { return H5T_NATIVE_DOUBLE; }
|
||||
}
|
||||
|
||||
|
||||
#define CHECK_ERROR(x,y) if ((x)<0) throw FLANNException((y));
|
||||
|
||||
template<typename T>
|
||||
void save_to_file(const cvflann::Matrix<T>& dataset, const String& filename, const String& name)
|
||||
{
|
||||
|
||||
#if H5Eset_auto_vers == 2
|
||||
H5Eset_auto( H5E_DEFAULT, NULL, NULL );
|
||||
#else
|
||||
H5Eset_auto( NULL, NULL );
|
||||
#endif
|
||||
|
||||
herr_t status;
|
||||
hid_t file_id;
|
||||
file_id = H5Fopen(filename.c_str(), H5F_ACC_RDWR, H5P_DEFAULT);
|
||||
if (file_id < 0) {
|
||||
file_id = H5Fcreate(filename.c_str(), H5F_ACC_EXCL, H5P_DEFAULT, H5P_DEFAULT);
|
||||
}
|
||||
CHECK_ERROR(file_id,"Error creating hdf5 file.");
|
||||
|
||||
hsize_t dimsf[2]; // dataset dimensions
|
||||
dimsf[0] = dataset.rows;
|
||||
dimsf[1] = dataset.cols;
|
||||
|
||||
hid_t space_id = H5Screate_simple(2, dimsf, NULL);
|
||||
hid_t memspace_id = H5Screate_simple(2, dimsf, NULL);
|
||||
|
||||
hid_t dataset_id;
|
||||
#if H5Dcreate_vers == 2
|
||||
dataset_id = H5Dcreate2(file_id, name.c_str(), get_hdf5_type<T>(), space_id, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
|
||||
#else
|
||||
dataset_id = H5Dcreate(file_id, name.c_str(), get_hdf5_type<T>(), space_id, H5P_DEFAULT);
|
||||
#endif
|
||||
|
||||
if (dataset_id<0) {
|
||||
#if H5Dopen_vers == 2
|
||||
dataset_id = H5Dopen2(file_id, name.c_str(), H5P_DEFAULT);
|
||||
#else
|
||||
dataset_id = H5Dopen(file_id, name.c_str());
|
||||
#endif
|
||||
}
|
||||
CHECK_ERROR(dataset_id,"Error creating or opening dataset in file.");
|
||||
|
||||
status = H5Dwrite(dataset_id, get_hdf5_type<T>(), memspace_id, space_id, H5P_DEFAULT, dataset.data );
|
||||
CHECK_ERROR(status, "Error writing to dataset");
|
||||
|
||||
H5Sclose(memspace_id);
|
||||
H5Sclose(space_id);
|
||||
H5Dclose(dataset_id);
|
||||
H5Fclose(file_id);
|
||||
|
||||
}
|
||||
|
||||
|
||||
template<typename T>
|
||||
void load_from_file(cvflann::Matrix<T>& dataset, const String& filename, const String& name)
|
||||
{
|
||||
herr_t status;
|
||||
hid_t file_id = H5Fopen(filename.c_str(), H5F_ACC_RDWR, H5P_DEFAULT);
|
||||
CHECK_ERROR(file_id,"Error opening hdf5 file.");
|
||||
|
||||
hid_t dataset_id;
|
||||
#if H5Dopen_vers == 2
|
||||
dataset_id = H5Dopen2(file_id, name.c_str(), H5P_DEFAULT);
|
||||
#else
|
||||
dataset_id = H5Dopen(file_id, name.c_str());
|
||||
#endif
|
||||
CHECK_ERROR(dataset_id,"Error opening dataset in file.");
|
||||
|
||||
hid_t space_id = H5Dget_space(dataset_id);
|
||||
|
||||
hsize_t dims_out[2];
|
||||
H5Sget_simple_extent_dims(space_id, dims_out, NULL);
|
||||
|
||||
dataset = cvflann::Matrix<T>(new T[dims_out[0]*dims_out[1]], dims_out[0], dims_out[1]);
|
||||
|
||||
status = H5Dread(dataset_id, get_hdf5_type<T>(), H5S_ALL, H5S_ALL, H5P_DEFAULT, dataset[0]);
|
||||
CHECK_ERROR(status, "Error reading dataset");
|
||||
|
||||
H5Sclose(space_id);
|
||||
H5Dclose(dataset_id);
|
||||
H5Fclose(file_id);
|
||||
}
|
||||
|
||||
|
||||
#ifdef HAVE_MPI
|
||||
|
||||
namespace mpi
|
||||
{
|
||||
/**
|
||||
* Loads a the hyperslice corresponding to this processor from a hdf5 file.
|
||||
* @param flann_dataset Dataset where the data is loaded
|
||||
* @param filename HDF5 file name
|
||||
* @param name Name of dataset inside file
|
||||
*/
|
||||
template<typename T>
|
||||
void load_from_file(cvflann::Matrix<T>& dataset, const String& filename, const String& name)
|
||||
{
|
||||
MPI_Comm comm = MPI_COMM_WORLD;
|
||||
MPI_Info info = MPI_INFO_NULL;
|
||||
|
||||
int mpi_size, mpi_rank;
|
||||
MPI_Comm_size(comm, &mpi_size);
|
||||
MPI_Comm_rank(comm, &mpi_rank);
|
||||
|
||||
herr_t status;
|
||||
|
||||
hid_t plist_id = H5Pcreate(H5P_FILE_ACCESS);
|
||||
H5Pset_fapl_mpio(plist_id, comm, info);
|
||||
hid_t file_id = H5Fopen(filename.c_str(), H5F_ACC_RDWR, plist_id);
|
||||
CHECK_ERROR(file_id,"Error opening hdf5 file.");
|
||||
H5Pclose(plist_id);
|
||||
hid_t dataset_id;
|
||||
#if H5Dopen_vers == 2
|
||||
dataset_id = H5Dopen2(file_id, name.c_str(), H5P_DEFAULT);
|
||||
#else
|
||||
dataset_id = H5Dopen(file_id, name.c_str());
|
||||
#endif
|
||||
CHECK_ERROR(dataset_id,"Error opening dataset in file.");
|
||||
|
||||
hid_t space_id = H5Dget_space(dataset_id);
|
||||
hsize_t dims[2];
|
||||
H5Sget_simple_extent_dims(space_id, dims, NULL);
|
||||
|
||||
hsize_t count[2];
|
||||
hsize_t offset[2];
|
||||
|
||||
hsize_t item_cnt = dims[0]/mpi_size+(dims[0]%mpi_size==0 ? 0 : 1);
|
||||
hsize_t cnt = (mpi_rank<mpi_size-1 ? item_cnt : dims[0]-item_cnt*(mpi_size-1));
|
||||
|
||||
count[0] = cnt;
|
||||
count[1] = dims[1];
|
||||
offset[0] = mpi_rank*item_cnt;
|
||||
offset[1] = 0;
|
||||
|
||||
hid_t memspace_id = H5Screate_simple(2,count,NULL);
|
||||
|
||||
H5Sselect_hyperslab(space_id, H5S_SELECT_SET, offset, NULL, count, NULL);
|
||||
|
||||
dataset.rows = count[0];
|
||||
dataset.cols = count[1];
|
||||
dataset.data = new T[dataset.rows*dataset.cols];
|
||||
|
||||
plist_id = H5Pcreate(H5P_DATASET_XFER);
|
||||
H5Pset_dxpl_mpio(plist_id, H5FD_MPIO_COLLECTIVE);
|
||||
status = H5Dread(dataset_id, get_hdf5_type<T>(), memspace_id, space_id, plist_id, dataset.data);
|
||||
CHECK_ERROR(status, "Error reading dataset");
|
||||
|
||||
H5Pclose(plist_id);
|
||||
H5Sclose(space_id);
|
||||
H5Sclose(memspace_id);
|
||||
H5Dclose(dataset_id);
|
||||
H5Fclose(file_id);
|
||||
}
|
||||
}
|
||||
#endif // HAVE_MPI
|
||||
} // namespace cvflann::mpi
|
||||
|
||||
//! @endcond
|
||||
|
||||
#endif /* OPENCV_FLANN_HDF5_H_ */
|
||||
@ -31,6 +31,8 @@
|
||||
#ifndef OPENCV_FLANN_HEAP_H_
|
||||
#define OPENCV_FLANN_HEAP_H_
|
||||
|
||||
//! @cond IGNORED
|
||||
|
||||
#include <algorithm>
|
||||
#include <vector>
|
||||
|
||||
@ -162,4 +164,6 @@ public:
|
||||
|
||||
}
|
||||
|
||||
//! @endcond
|
||||
|
||||
#endif //OPENCV_FLANN_HEAP_H_
|
||||
|
||||
@ -31,6 +31,8 @@
|
||||
#ifndef OPENCV_FLANN_HIERARCHICAL_CLUSTERING_INDEX_H_
|
||||
#define OPENCV_FLANN_HIERARCHICAL_CLUSTERING_INDEX_H_
|
||||
|
||||
//! @cond IGNORED
|
||||
|
||||
#include <algorithm>
|
||||
#include <map>
|
||||
#include <cassert>
|
||||
@ -845,4 +847,6 @@ private:
|
||||
|
||||
}
|
||||
|
||||
//! @endcond
|
||||
|
||||
#endif /* OPENCV_FLANN_HIERARCHICAL_CLUSTERING_INDEX_H_ */
|
||||
|
||||
@ -31,6 +31,8 @@
|
||||
#ifndef OPENCV_FLANN_INDEX_TESTING_H_
|
||||
#define OPENCV_FLANN_INDEX_TESTING_H_
|
||||
|
||||
//! @cond IGNORED
|
||||
|
||||
#include <cstring>
|
||||
#include <cassert>
|
||||
#include <cmath>
|
||||
@ -315,4 +317,6 @@ void test_index_precisions(NNIndex<Distance>& index, const Matrix<typename Dista
|
||||
|
||||
}
|
||||
|
||||
//! @endcond
|
||||
|
||||
#endif //OPENCV_FLANN_INDEX_TESTING_H_
|
||||
|
||||
@ -31,6 +31,8 @@
|
||||
#ifndef OPENCV_FLANN_KDTREE_INDEX_H_
|
||||
#define OPENCV_FLANN_KDTREE_INDEX_H_
|
||||
|
||||
//! @cond IGNORED
|
||||
|
||||
#include <algorithm>
|
||||
#include <map>
|
||||
#include <cassert>
|
||||
@ -623,4 +625,6 @@ private:
|
||||
|
||||
}
|
||||
|
||||
//! @endcond
|
||||
|
||||
#endif //OPENCV_FLANN_KDTREE_INDEX_H_
|
||||
|
||||
@ -31,6 +31,8 @@
|
||||
#ifndef OPENCV_FLANN_KDTREE_SINGLE_INDEX_H_
|
||||
#define OPENCV_FLANN_KDTREE_SINGLE_INDEX_H_
|
||||
|
||||
//! @cond IGNORED
|
||||
|
||||
#include <algorithm>
|
||||
#include <map>
|
||||
#include <cassert>
|
||||
@ -632,4 +634,6 @@ private:
|
||||
|
||||
}
|
||||
|
||||
//! @endcond
|
||||
|
||||
#endif //OPENCV_FLANN_KDTREE_SINGLE_INDEX_H_
|
||||
|
||||
@ -31,6 +31,8 @@
|
||||
#ifndef OPENCV_FLANN_KMEANS_INDEX_H_
|
||||
#define OPENCV_FLANN_KMEANS_INDEX_H_
|
||||
|
||||
//! @cond IGNORED
|
||||
|
||||
#include <algorithm>
|
||||
#include <map>
|
||||
#include <cassert>
|
||||
@ -1169,4 +1171,6 @@ private:
|
||||
|
||||
}
|
||||
|
||||
//! @endcond
|
||||
|
||||
#endif //OPENCV_FLANN_KMEANS_INDEX_H_
|
||||
|
||||
@ -31,6 +31,8 @@
|
||||
#ifndef OPENCV_FLANN_LINEAR_INDEX_H_
|
||||
#define OPENCV_FLANN_LINEAR_INDEX_H_
|
||||
|
||||
//! @cond IGNORED
|
||||
|
||||
#include "general.h"
|
||||
#include "nn_index.h"
|
||||
|
||||
@ -129,4 +131,6 @@ private:
|
||||
|
||||
}
|
||||
|
||||
//! @endcond
|
||||
|
||||
#endif // OPENCV_FLANN_LINEAR_INDEX_H_
|
||||
|
||||
@ -31,6 +31,8 @@
|
||||
#ifndef OPENCV_FLANN_LOGGER_H
|
||||
#define OPENCV_FLANN_LOGGER_H
|
||||
|
||||
//! @cond IGNORED
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdarg.h>
|
||||
|
||||
@ -132,4 +134,6 @@ private:
|
||||
|
||||
}
|
||||
|
||||
//! @endcond
|
||||
|
||||
#endif //OPENCV_FLANN_LOGGER_H
|
||||
|
||||
@ -35,6 +35,8 @@
|
||||
#ifndef OPENCV_FLANN_LSH_INDEX_H_
|
||||
#define OPENCV_FLANN_LSH_INDEX_H_
|
||||
|
||||
//! @cond IGNORED
|
||||
|
||||
#include <algorithm>
|
||||
#include <cassert>
|
||||
#include <cstring>
|
||||
@ -389,4 +391,6 @@ private:
|
||||
};
|
||||
}
|
||||
|
||||
//! @endcond
|
||||
|
||||
#endif //OPENCV_FLANN_LSH_INDEX_H_
|
||||
|
||||
@ -35,6 +35,8 @@
|
||||
#ifndef OPENCV_FLANN_LSH_TABLE_H_
|
||||
#define OPENCV_FLANN_LSH_TABLE_H_
|
||||
|
||||
//! @cond IGNORED
|
||||
|
||||
#include <algorithm>
|
||||
#include <iostream>
|
||||
#include <iomanip>
|
||||
@ -510,4 +512,6 @@ inline LshStats LshTable<unsigned char>::getStats() const
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
//! @endcond
|
||||
|
||||
#endif /* OPENCV_FLANN_LSH_TABLE_H_ */
|
||||
|
||||
@ -31,6 +31,8 @@
|
||||
#ifndef OPENCV_FLANN_DATASET_H_
|
||||
#define OPENCV_FLANN_DATASET_H_
|
||||
|
||||
//! @cond IGNORED
|
||||
|
||||
#include <stdio.h>
|
||||
|
||||
#include "general.h"
|
||||
@ -113,4 +115,6 @@ public:
|
||||
|
||||
}
|
||||
|
||||
//! @endcond
|
||||
|
||||
#endif //OPENCV_FLANN_DATASET_H_
|
||||
|
||||
@ -43,6 +43,8 @@
|
||||
#ifndef OPENCV_MINIFLANN_HPP
|
||||
#define OPENCV_MINIFLANN_HPP
|
||||
|
||||
//! @cond IGNORED
|
||||
|
||||
#include "opencv2/core.hpp"
|
||||
#include "opencv2/flann/defines.h"
|
||||
|
||||
@ -174,4 +176,6 @@ protected:
|
||||
|
||||
} } // namespace cv::flann
|
||||
|
||||
//! @endcond
|
||||
|
||||
#endif
|
||||
|
||||
@ -36,6 +36,8 @@
|
||||
#include "result_set.h"
|
||||
#include "params.h"
|
||||
|
||||
//! @cond IGNORED
|
||||
|
||||
namespace cvflann
|
||||
{
|
||||
|
||||
@ -174,4 +176,6 @@ public:
|
||||
|
||||
}
|
||||
|
||||
//! @endcond
|
||||
|
||||
#endif //OPENCV_FLANN_NNINDEX_H
|
||||
|
||||
@ -31,6 +31,8 @@
|
||||
#ifndef OPENCV_FLANN_OBJECT_FACTORY_H_
|
||||
#define OPENCV_FLANN_OBJECT_FACTORY_H_
|
||||
|
||||
//! @cond IGNORED
|
||||
|
||||
#include <map>
|
||||
|
||||
namespace cvflann
|
||||
@ -88,4 +90,6 @@ private:
|
||||
|
||||
}
|
||||
|
||||
//! @endcond
|
||||
|
||||
#endif /* OPENCV_FLANN_OBJECT_FACTORY_H_ */
|
||||
|
||||
@ -30,6 +30,8 @@
|
||||
#ifndef OPENCV_FLANN_PARAMS_H_
|
||||
#define OPENCV_FLANN_PARAMS_H_
|
||||
|
||||
//! @cond IGNORED
|
||||
|
||||
#include "any.h"
|
||||
#include "general.h"
|
||||
#include <iostream>
|
||||
@ -95,5 +97,6 @@ inline void print_params(const IndexParams& params)
|
||||
|
||||
}
|
||||
|
||||
//! @endcond
|
||||
|
||||
#endif /* OPENCV_FLANN_PARAMS_H_ */
|
||||
|
||||
@ -31,6 +31,8 @@
|
||||
#ifndef OPENCV_FLANN_RANDOM_H
|
||||
#define OPENCV_FLANN_RANDOM_H
|
||||
|
||||
//! @cond IGNORED
|
||||
|
||||
#include <algorithm>
|
||||
#include <cstdlib>
|
||||
#include <vector>
|
||||
@ -152,4 +154,6 @@ public:
|
||||
|
||||
}
|
||||
|
||||
//! @endcond
|
||||
|
||||
#endif //OPENCV_FLANN_RANDOM_H
|
||||
|
||||
@ -31,6 +31,8 @@
|
||||
#ifndef OPENCV_FLANN_RESULTSET_H
|
||||
#define OPENCV_FLANN_RESULTSET_H
|
||||
|
||||
//! @cond IGNORED
|
||||
|
||||
#include <algorithm>
|
||||
#include <cstring>
|
||||
#include <iostream>
|
||||
@ -540,4 +542,6 @@ private:
|
||||
};
|
||||
}
|
||||
|
||||
//! @endcond
|
||||
|
||||
#endif //OPENCV_FLANN_RESULTSET_H
|
||||
|
||||
@ -30,6 +30,8 @@
|
||||
#ifndef OPENCV_FLANN_SAMPLING_H_
|
||||
#define OPENCV_FLANN_SAMPLING_H_
|
||||
|
||||
//! @cond IGNORED
|
||||
|
||||
#include "matrix.h"
|
||||
#include "random.h"
|
||||
|
||||
@ -77,5 +79,6 @@ Matrix<T> random_sample(const Matrix<T>& srcMatrix, size_t size)
|
||||
|
||||
} // namespace
|
||||
|
||||
//! @endcond
|
||||
|
||||
#endif /* OPENCV_FLANN_SAMPLING_H_ */
|
||||
|
||||
@ -29,6 +29,8 @@
|
||||
#ifndef OPENCV_FLANN_SAVING_H_
|
||||
#define OPENCV_FLANN_SAVING_H_
|
||||
|
||||
//! @cond IGNORED
|
||||
|
||||
#include <cstring>
|
||||
#include <vector>
|
||||
|
||||
@ -184,4 +186,6 @@ void load_value(FILE* stream, std::vector<T>& value)
|
||||
|
||||
}
|
||||
|
||||
//! @endcond
|
||||
|
||||
#endif /* OPENCV_FLANN_SAVING_H_ */
|
||||
|
||||
@ -31,6 +31,8 @@
|
||||
#ifndef OPENCV_FLANN_SIMPLEX_DOWNHILL_H_
|
||||
#define OPENCV_FLANN_SIMPLEX_DOWNHILL_H_
|
||||
|
||||
//! @cond IGNORED
|
||||
|
||||
namespace cvflann
|
||||
{
|
||||
|
||||
@ -183,4 +185,6 @@ float optimizeSimplexDownhill(T* points, int n, F func, float* vals = NULL )
|
||||
|
||||
}
|
||||
|
||||
//! @endcond
|
||||
|
||||
#endif //OPENCV_FLANN_SIMPLEX_DOWNHILL_H_
|
||||
|
||||
@ -31,6 +31,8 @@
|
||||
#ifndef OPENCV_FLANN_TIMER_H
|
||||
#define OPENCV_FLANN_TIMER_H
|
||||
|
||||
//! @cond IGNORED
|
||||
|
||||
#include <time.h>
|
||||
#include "opencv2/core.hpp"
|
||||
#include "opencv2/core/utility.hpp"
|
||||
@ -91,4 +93,6 @@ public:
|
||||
|
||||
}
|
||||
|
||||
//! @endcond
|
||||
|
||||
#endif // FLANN_TIMER_H
|
||||
|
||||
@ -197,7 +197,8 @@ enum WindowPropertyFlags {
|
||||
WND_PROP_AUTOSIZE = 1, //!< autosize property (can be WINDOW_NORMAL or WINDOW_AUTOSIZE).
|
||||
WND_PROP_ASPECT_RATIO = 2, //!< window's aspect ration (can be set to WINDOW_FREERATIO or WINDOW_KEEPRATIO).
|
||||
WND_PROP_OPENGL = 3, //!< opengl support.
|
||||
WND_PROP_VISIBLE = 4 //!< checks whether the window exists and is visible
|
||||
WND_PROP_VISIBLE = 4, //!< checks whether the window exists and is visible
|
||||
WND_PROP_TOPMOST = 5 //!< property to toggle normal window being topmost or not
|
||||
};
|
||||
|
||||
//! Mouse Events see cv::MouseCallback
|
||||
|
||||
@ -109,6 +109,12 @@ double cvGetOpenGlProp_GTK(const char* name);
|
||||
|
||||
double cvGetPropVisible_W32(const char* name);
|
||||
|
||||
double cvGetPropTopmost_W32(const char* name);
|
||||
double cvGetPropTopmost_COCOA(const char* name);
|
||||
|
||||
void cvSetPropTopmost_W32(const char* name, const bool topmost);
|
||||
void cvSetPropTopmost_COCOA(const char* name, const bool topmost);
|
||||
|
||||
//for QT
|
||||
#if defined (HAVE_QT)
|
||||
CvRect cvGetWindowRect_QT(const char* name);
|
||||
|
||||
@ -42,6 +42,7 @@
|
||||
#include "precomp.hpp"
|
||||
#include <map>
|
||||
#include "opencv2/core/opengl.hpp"
|
||||
#include "opencv2/core/utils/logger.hpp"
|
||||
|
||||
// in later times, use this file as a dispatcher to implementations like cvcap.cpp
|
||||
|
||||
@ -81,6 +82,16 @@ CV_IMPL void cvSetWindowProperty(const char* name, int prop_id, double prop_valu
|
||||
#endif
|
||||
break;
|
||||
|
||||
case cv::WND_PROP_TOPMOST:
|
||||
#if defined(HAVE_WIN32UI)
|
||||
cvSetPropTopmost_W32(name, (prop_value != 0 ? true : false));
|
||||
#elif defined(HAVE_COCOA)
|
||||
cvSetPropTopmost_COCOA(name, (prop_value != 0 ? true : false));
|
||||
#else
|
||||
CV_LOG_WARNING(NULL, "Property WND_PROP_TOPMOST is not supported on current GUI backend");
|
||||
#endif
|
||||
break;
|
||||
|
||||
default:;
|
||||
}
|
||||
}
|
||||
@ -158,6 +169,18 @@ CV_IMPL double cvGetWindowProperty(const char* name, int prop_id)
|
||||
return -1;
|
||||
#endif
|
||||
break;
|
||||
|
||||
case cv::WND_PROP_TOPMOST:
|
||||
#if defined(HAVE_WIN32UI)
|
||||
return cvGetPropTopmost_W32(name);
|
||||
#elif defined(HAVE_COCOA)
|
||||
return cvGetPropTopmost_COCOA(name);
|
||||
#else
|
||||
CV_LOG_WARNING(NULL, "Property WND_PROP_TOPMOST is not supported on current GUI backend");
|
||||
return -1;
|
||||
#endif
|
||||
break;
|
||||
|
||||
default:
|
||||
return -1;
|
||||
}
|
||||
|
||||
@ -713,6 +713,68 @@ void cvSetModeWindow_COCOA( const char* name, double prop_value )
|
||||
__END__;
|
||||
}
|
||||
|
||||
double cvGetPropTopmost_COCOA(const char* name)
|
||||
{
|
||||
double result = -1;
|
||||
CVWindow* window = nil;
|
||||
|
||||
CV_FUNCNAME("cvGetPropTopmost_COCOA");
|
||||
|
||||
__BEGIN__;
|
||||
if (name == NULL)
|
||||
{
|
||||
CV_ERROR(CV_StsNullPtr, "NULL name string");
|
||||
}
|
||||
|
||||
window = cvGetWindow(name);
|
||||
if (window == NULL)
|
||||
{
|
||||
CV_ERROR(CV_StsNullPtr, "NULL window");
|
||||
}
|
||||
|
||||
result = (window.level == NSStatusWindowLevel) ? 1 : 0;
|
||||
|
||||
__END__;
|
||||
return result;
|
||||
}
|
||||
|
||||
void cvSetPropTopmost_COCOA( const char* name, const bool topmost )
|
||||
{
|
||||
CVWindow *window = nil;
|
||||
NSAutoreleasePool* localpool = nil;
|
||||
CV_FUNCNAME( "cvSetPropTopmost_COCOA" );
|
||||
|
||||
__BEGIN__;
|
||||
if( name == NULL )
|
||||
{
|
||||
CV_ERROR( CV_StsNullPtr, "NULL name string" );
|
||||
}
|
||||
|
||||
window = cvGetWindow(name);
|
||||
if ( window == NULL )
|
||||
{
|
||||
CV_ERROR( CV_StsNullPtr, "NULL window" );
|
||||
}
|
||||
|
||||
if ([[window contentView] isInFullScreenMode])
|
||||
{
|
||||
EXIT;
|
||||
}
|
||||
|
||||
localpool = [[NSAutoreleasePool alloc] init];
|
||||
if (topmost)
|
||||
{
|
||||
[window makeKeyAndOrderFront:window.self];
|
||||
[window setLevel:CGWindowLevelForKey(kCGMaximumWindowLevelKey)];
|
||||
}
|
||||
else
|
||||
{
|
||||
[window makeKeyAndOrderFront:nil];
|
||||
}
|
||||
[localpool drain];
|
||||
__END__;
|
||||
}
|
||||
|
||||
void cv::setWindowTitle(const String& winname, const String& title)
|
||||
{
|
||||
CVWindow *window = cvGetWindow(winname.c_str());
|
||||
|
||||
@ -40,6 +40,9 @@
|
||||
//M*/
|
||||
|
||||
#include "precomp.hpp"
|
||||
|
||||
using namespace cv;
|
||||
|
||||
#include <windowsx.h> // required for GET_X_LPARAM() and GET_Y_LPARAM() macros
|
||||
|
||||
#if defined _WIN32
|
||||
@ -551,6 +554,48 @@ void cvSetModeWindow_W32( const char* name, double prop_value)//Yannick Verdie
|
||||
__END__;
|
||||
}
|
||||
|
||||
double cvGetPropTopmost_W32(const char* name)
|
||||
{
|
||||
double result = -1;
|
||||
|
||||
CV_Assert(name);
|
||||
|
||||
CvWindow* window = icvFindWindowByName(name);
|
||||
if (!window)
|
||||
CV_Error(Error::StsNullPtr, "NULL window");
|
||||
|
||||
LONG style = GetWindowLongA(window->frame, GWL_EXSTYLE); // -20
|
||||
if (!style)
|
||||
{
|
||||
std::ostringstream errorMsg;
|
||||
errorMsg << "window(" << name << "): failed to retrieve extended window style using GetWindowLongA(); error code: " << GetLastError();
|
||||
CV_Error(Error::StsError, errorMsg.str().c_str());
|
||||
}
|
||||
|
||||
result = (style & WS_EX_TOPMOST) == WS_EX_TOPMOST;
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
void cvSetPropTopmost_W32(const char* name, const bool topmost)
|
||||
{
|
||||
CV_Assert(name);
|
||||
|
||||
CvWindow* window = icvFindWindowByName(name);
|
||||
if (!window)
|
||||
CV_Error(Error::StsNullPtr, "NULL window");
|
||||
|
||||
HWND flag = topmost ? HWND_TOPMOST : HWND_TOP;
|
||||
BOOL success = SetWindowPos(window->frame, flag, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE);
|
||||
|
||||
if (!success)
|
||||
{
|
||||
std::ostringstream errorMsg;
|
||||
errorMsg << "window(" << name << "): error reported by SetWindowPos(" << (topmost ? "HWND_TOPMOST" : "HWND_TOP") << "), error code: " << GetLastError();
|
||||
CV_Error(Error::StsError, errorMsg.str().c_str());
|
||||
}
|
||||
}
|
||||
|
||||
void cv::setWindowTitle(const String& winname, const String& title)
|
||||
{
|
||||
CvWindow* window = icvFindWindowByName(winname.c_str());
|
||||
|
||||
@ -5,9 +5,24 @@
|
||||
|
||||
namespace opencv_test {
|
||||
|
||||
enum PerfSqMatDepth{
|
||||
DEPTH_32S_32S = 0,
|
||||
DEPTH_32S_32F,
|
||||
DEPTH_32S_64F,
|
||||
DEPTH_32F_32F,
|
||||
DEPTH_32F_64F,
|
||||
DEPTH_64F_64F};
|
||||
|
||||
CV_ENUM(IntegralOutputDepths, DEPTH_32S_32S, DEPTH_32S_32F, DEPTH_32S_64F, DEPTH_32F_32F, DEPTH_32F_64F, DEPTH_64F_64F);
|
||||
|
||||
static int extraOutputDepths[6][2] = {{CV_32S, CV_32S}, {CV_32S, CV_32F}, {CV_32S, CV_64F}, {CV_32F, CV_32F}, {CV_32F, CV_64F}, {CV_64F, CV_64F}};
|
||||
|
||||
typedef tuple<Size, MatType, MatDepth> Size_MatType_OutMatDepth_t;
|
||||
typedef perf::TestBaseWithParam<Size_MatType_OutMatDepth_t> Size_MatType_OutMatDepth;
|
||||
|
||||
typedef tuple<Size, MatType, IntegralOutputDepths> Size_MatType_OutMatDepthArray_t;
|
||||
typedef perf::TestBaseWithParam<Size_MatType_OutMatDepthArray_t> Size_MatType_OutMatDepthArray;
|
||||
|
||||
PERF_TEST_P(Size_MatType_OutMatDepth, integral,
|
||||
testing::Combine(
|
||||
testing::Values(TYPICAL_MAT_SIZES),
|
||||
@ -55,6 +70,32 @@ PERF_TEST_P(Size_MatType_OutMatDepth, integral_sqsum,
|
||||
SANITY_CHECK(sqsum, 1e-6);
|
||||
}
|
||||
|
||||
PERF_TEST_P(Size_MatType_OutMatDepthArray, DISABLED_integral_sqsum_full,
|
||||
testing::Combine(
|
||||
testing::Values(TYPICAL_MAT_SIZES),
|
||||
testing::Values(CV_8UC1, CV_8UC2, CV_8UC3, CV_8UC4),
|
||||
testing::Values(DEPTH_32S_32S, DEPTH_32S_32F, DEPTH_32S_64F, DEPTH_32F_32F, DEPTH_32F_64F, DEPTH_64F_64F)
|
||||
)
|
||||
)
|
||||
{
|
||||
Size sz = get<0>(GetParam());
|
||||
int matType = get<1>(GetParam());
|
||||
int *outputDepths = (int *)extraOutputDepths[get<2>(GetParam())];
|
||||
int sdepth = outputDepths[0];
|
||||
int sqdepth = outputDepths[1];
|
||||
|
||||
Mat src(sz, matType);
|
||||
Mat sum(sz, sdepth);
|
||||
Mat sqsum(sz, sqdepth);
|
||||
|
||||
declare.in(src, WARMUP_RNG).out(sum, sqsum);
|
||||
declare.time(100);
|
||||
|
||||
TEST_CYCLE() integral(src, sum, sqsum, sdepth, sqdepth);
|
||||
|
||||
SANITY_CHECK_NOTHING();
|
||||
}
|
||||
|
||||
PERF_TEST_P( Size_MatType_OutMatDepth, integral_sqsum_tilted,
|
||||
testing::Combine(
|
||||
testing::Values(TYPICAL_MAT_SIZES),
|
||||
|
||||
@ -2686,6 +2686,258 @@ void cv::warpAffine( InputArray _src, OutputArray _dst,
|
||||
|
||||
namespace cv
|
||||
{
|
||||
#if CV_SIMD128_64F
|
||||
void WarpPerspectiveLine_ProcessNN_CV_SIMD(const double *M, short* xy, double X0, double Y0, double W0, int bw)
|
||||
{
|
||||
const v_float64x2 v_M0 = v_setall_f64(M[0]);
|
||||
const v_float64x2 v_M3 = v_setall_f64(M[3]);
|
||||
const v_float64x2 v_M6 = v_setall_f64(M[6]);
|
||||
const v_float64x2 v_intmax = v_setall_f64((double)INT_MAX);
|
||||
const v_float64x2 v_intmin = v_setall_f64((double)INT_MIN);
|
||||
const v_float64x2 v_2 = v_setall_f64(2.0);
|
||||
const v_float64x2 v_zero = v_setzero_f64();
|
||||
const v_float64x2 v_1 = v_setall_f64(1.0);
|
||||
|
||||
int x1 = 0;
|
||||
v_float64x2 v_X0d = v_setall_f64(X0);
|
||||
v_float64x2 v_Y0d = v_setall_f64(Y0);
|
||||
v_float64x2 v_W0 = v_setall_f64(W0);
|
||||
v_float64x2 v_x1(0.0, 1.0);
|
||||
|
||||
for (; x1 <= bw - 16; x1 += 16)
|
||||
{
|
||||
// 0-3
|
||||
v_int32x4 v_X0, v_Y0;
|
||||
{
|
||||
v_float64x2 v_W = v_muladd(v_M6, v_x1, v_W0);
|
||||
v_W = v_select(v_W != v_zero, v_1 / v_W, v_zero);
|
||||
v_float64x2 v_fX0 = v_max(v_intmin, v_min(v_intmax, v_muladd(v_M0, v_x1, v_X0d) * v_W));
|
||||
v_float64x2 v_fY0 = v_max(v_intmin, v_min(v_intmax, v_muladd(v_M3, v_x1, v_Y0d) * v_W));
|
||||
v_x1 += v_2;
|
||||
|
||||
v_W = v_muladd(v_M6, v_x1, v_W0);
|
||||
v_W = v_select(v_W != v_zero, v_1 / v_W, v_zero);
|
||||
v_float64x2 v_fX1 = v_max(v_intmin, v_min(v_intmax, v_muladd(v_M0, v_x1, v_X0d) * v_W));
|
||||
v_float64x2 v_fY1 = v_max(v_intmin, v_min(v_intmax, v_muladd(v_M3, v_x1, v_Y0d) * v_W));
|
||||
v_x1 += v_2;
|
||||
|
||||
v_X0 = v_round(v_fX0, v_fX1);
|
||||
v_Y0 = v_round(v_fY0, v_fY1);
|
||||
}
|
||||
|
||||
// 4-7
|
||||
v_int32x4 v_X1, v_Y1;
|
||||
{
|
||||
v_float64x2 v_W = v_muladd(v_M6, v_x1, v_W0);
|
||||
v_W = v_select(v_W != v_zero, v_1 / v_W, v_zero);
|
||||
v_float64x2 v_fX0 = v_max(v_intmin, v_min(v_intmax, v_muladd(v_M0, v_x1, v_X0d) * v_W));
|
||||
v_float64x2 v_fY0 = v_max(v_intmin, v_min(v_intmax, v_muladd(v_M3, v_x1, v_Y0d) * v_W));
|
||||
v_x1 += v_2;
|
||||
|
||||
v_W = v_muladd(v_M6, v_x1, v_W0);
|
||||
v_W = v_select(v_W != v_zero, v_1 / v_W, v_zero);
|
||||
v_float64x2 v_fX1 = v_max(v_intmin, v_min(v_intmax, v_muladd(v_M0, v_x1, v_X0d) * v_W));
|
||||
v_float64x2 v_fY1 = v_max(v_intmin, v_min(v_intmax, v_muladd(v_M3, v_x1, v_Y0d) * v_W));
|
||||
v_x1 += v_2;
|
||||
|
||||
v_X1 = v_round(v_fX0, v_fX1);
|
||||
v_Y1 = v_round(v_fY0, v_fY1);
|
||||
}
|
||||
|
||||
// 8-11
|
||||
v_int32x4 v_X2, v_Y2;
|
||||
{
|
||||
v_float64x2 v_W = v_muladd(v_M6, v_x1, v_W0);
|
||||
v_W = v_select(v_W != v_zero, v_1 / v_W, v_zero);
|
||||
v_float64x2 v_fX0 = v_max(v_intmin, v_min(v_intmax, v_muladd(v_M0, v_x1, v_X0d) * v_W));
|
||||
v_float64x2 v_fY0 = v_max(v_intmin, v_min(v_intmax, v_muladd(v_M3, v_x1, v_Y0d) * v_W));
|
||||
v_x1 += v_2;
|
||||
|
||||
v_W = v_muladd(v_M6, v_x1, v_W0);
|
||||
v_W = v_select(v_W != v_zero, v_1 / v_W, v_zero);
|
||||
v_float64x2 v_fX1 = v_max(v_intmin, v_min(v_intmax, v_muladd(v_M0, v_x1, v_X0d) * v_W));
|
||||
v_float64x2 v_fY1 = v_max(v_intmin, v_min(v_intmax, v_muladd(v_M3, v_x1, v_Y0d) * v_W));
|
||||
v_x1 += v_2;
|
||||
|
||||
v_X2 = v_round(v_fX0, v_fX1);
|
||||
v_Y2 = v_round(v_fY0, v_fY1);
|
||||
}
|
||||
|
||||
// 12-15
|
||||
v_int32x4 v_X3, v_Y3;
|
||||
{
|
||||
v_float64x2 v_W = v_muladd(v_M6, v_x1, v_W0);
|
||||
v_W = v_select(v_W != v_zero, v_1 / v_W, v_zero);
|
||||
v_float64x2 v_fX0 = v_max(v_intmin, v_min(v_intmax, v_muladd(v_M0, v_x1, v_X0d) * v_W));
|
||||
v_float64x2 v_fY0 = v_max(v_intmin, v_min(v_intmax, v_muladd(v_M3, v_x1, v_Y0d) * v_W));
|
||||
v_x1 += v_2;
|
||||
|
||||
v_W = v_muladd(v_M6, v_x1, v_W0);
|
||||
v_W = v_select(v_W != v_zero, v_1 / v_W, v_zero);
|
||||
v_float64x2 v_fX1 = v_max(v_intmin, v_min(v_intmax, v_muladd(v_M0, v_x1, v_X0d) * v_W));
|
||||
v_float64x2 v_fY1 = v_max(v_intmin, v_min(v_intmax, v_muladd(v_M3, v_x1, v_Y0d) * v_W));
|
||||
v_x1 += v_2;
|
||||
|
||||
v_X3 = v_round(v_fX0, v_fX1);
|
||||
v_Y3 = v_round(v_fY0, v_fY1);
|
||||
}
|
||||
|
||||
// convert to 16s
|
||||
v_X0 = v_reinterpret_as_s32(v_pack(v_X0, v_X1));
|
||||
v_X1 = v_reinterpret_as_s32(v_pack(v_X2, v_X3));
|
||||
v_Y0 = v_reinterpret_as_s32(v_pack(v_Y0, v_Y1));
|
||||
v_Y1 = v_reinterpret_as_s32(v_pack(v_Y2, v_Y3));
|
||||
|
||||
v_store_interleave(xy + x1 * 2, (v_reinterpret_as_s16)(v_X0), (v_reinterpret_as_s16)(v_Y0));
|
||||
v_store_interleave(xy + x1 * 2 + 16, (v_reinterpret_as_s16)(v_X1), (v_reinterpret_as_s16)(v_Y1));
|
||||
}
|
||||
|
||||
for( ; x1 < bw; x1++ )
|
||||
{
|
||||
double W = W0 + M[6]*x1;
|
||||
W = W ? 1./W : 0;
|
||||
double fX = std::max((double)INT_MIN, std::min((double)INT_MAX, (X0 + M[0]*x1)*W));
|
||||
double fY = std::max((double)INT_MIN, std::min((double)INT_MAX, (Y0 + M[3]*x1)*W));
|
||||
int X = saturate_cast<int>(fX);
|
||||
int Y = saturate_cast<int>(fY);
|
||||
|
||||
xy[x1*2] = saturate_cast<short>(X);
|
||||
xy[x1*2+1] = saturate_cast<short>(Y);
|
||||
}
|
||||
}
|
||||
|
||||
void WarpPerspectiveLine_Process_CV_SIMD(const double *M, short* xy, short* alpha, double X0, double Y0, double W0, int bw)
|
||||
{
|
||||
const v_float64x2 v_M0 = v_setall_f64(M[0]);
|
||||
const v_float64x2 v_M3 = v_setall_f64(M[3]);
|
||||
const v_float64x2 v_M6 = v_setall_f64(M[6]);
|
||||
const v_float64x2 v_intmax = v_setall_f64((double)INT_MAX);
|
||||
const v_float64x2 v_intmin = v_setall_f64((double)INT_MIN);
|
||||
const v_float64x2 v_2 = v_setall_f64(2.0);
|
||||
const v_float64x2 v_zero = v_setzero_f64();
|
||||
const v_float64x2 v_its = v_setall_f64((double)INTER_TAB_SIZE);
|
||||
const v_int32x4 v_itsi1 = v_setall_s32(INTER_TAB_SIZE - 1);
|
||||
|
||||
int x1 = 0;
|
||||
|
||||
v_float64x2 v_X0d = v_setall_f64(X0);
|
||||
v_float64x2 v_Y0d = v_setall_f64(Y0);
|
||||
v_float64x2 v_W0 = v_setall_f64(W0);
|
||||
v_float64x2 v_x1(0.0, 1.0);
|
||||
|
||||
for (; x1 <= bw - 16; x1 += 16)
|
||||
{
|
||||
// 0-3
|
||||
v_int32x4 v_X0, v_Y0;
|
||||
{
|
||||
v_float64x2 v_W = v_muladd(v_M6, v_x1, v_W0);
|
||||
v_W = v_select(v_W != v_zero, v_its / v_W, v_zero);
|
||||
v_float64x2 v_fX0 = v_max(v_intmin, v_min(v_intmax, v_muladd(v_M0, v_x1, v_X0d) * v_W));
|
||||
v_float64x2 v_fY0 = v_max(v_intmin, v_min(v_intmax, v_muladd(v_M3, v_x1, v_Y0d) * v_W));
|
||||
v_x1 += v_2;
|
||||
|
||||
v_W = v_muladd(v_M6, v_x1, v_W0);
|
||||
v_W = v_select(v_W != v_zero, v_its / v_W, v_zero);
|
||||
v_float64x2 v_fX1 = v_max(v_intmin, v_min(v_intmax, v_muladd(v_M0, v_x1, v_X0d) * v_W));
|
||||
v_float64x2 v_fY1 = v_max(v_intmin, v_min(v_intmax, v_muladd(v_M3, v_x1, v_Y0d) * v_W));
|
||||
v_x1 += v_2;
|
||||
|
||||
v_X0 = v_round(v_fX0, v_fX1);
|
||||
v_Y0 = v_round(v_fY0, v_fY1);
|
||||
}
|
||||
|
||||
// 4-7
|
||||
v_int32x4 v_X1, v_Y1;
|
||||
{
|
||||
v_float64x2 v_W = v_muladd(v_M6, v_x1, v_W0);
|
||||
v_W = v_select(v_W != v_zero, v_its / v_W, v_zero);
|
||||
v_float64x2 v_fX0 = v_max(v_intmin, v_min(v_intmax, v_muladd(v_M0, v_x1, v_X0d) * v_W));
|
||||
v_float64x2 v_fY0 = v_max(v_intmin, v_min(v_intmax, v_muladd(v_M3, v_x1, v_Y0d) * v_W));
|
||||
v_x1 += v_2;
|
||||
|
||||
v_W = v_muladd(v_M6, v_x1, v_W0);
|
||||
v_W = v_select(v_W != v_zero, v_its / v_W, v_zero);
|
||||
v_float64x2 v_fX1 = v_max(v_intmin, v_min(v_intmax, v_muladd(v_M0, v_x1, v_X0d) * v_W));
|
||||
v_float64x2 v_fY1 = v_max(v_intmin, v_min(v_intmax, v_muladd(v_M3, v_x1, v_Y0d) * v_W));
|
||||
v_x1 += v_2;
|
||||
|
||||
v_X1 = v_round(v_fX0, v_fX1);
|
||||
v_Y1 = v_round(v_fY0, v_fY1);
|
||||
}
|
||||
|
||||
// 8-11
|
||||
v_int32x4 v_X2, v_Y2;
|
||||
{
|
||||
v_float64x2 v_W = v_muladd(v_M6, v_x1, v_W0);
|
||||
v_W = v_select(v_W != v_zero, v_its / v_W, v_zero);
|
||||
v_float64x2 v_fX0 = v_max(v_intmin, v_min(v_intmax, v_muladd(v_M0, v_x1, v_X0d) * v_W));
|
||||
v_float64x2 v_fY0 = v_max(v_intmin, v_min(v_intmax, v_muladd(v_M3, v_x1, v_Y0d) * v_W));
|
||||
v_x1 += v_2;
|
||||
|
||||
v_W = v_muladd(v_M6, v_x1, v_W0);
|
||||
v_W = v_select(v_W != v_zero, v_its / v_W, v_zero);
|
||||
v_float64x2 v_fX1 = v_max(v_intmin, v_min(v_intmax, v_muladd(v_M0, v_x1, v_X0d) * v_W));
|
||||
v_float64x2 v_fY1 = v_max(v_intmin, v_min(v_intmax, v_muladd(v_M3, v_x1, v_Y0d) * v_W));
|
||||
v_x1 += v_2;
|
||||
|
||||
v_X2 = v_round(v_fX0, v_fX1);
|
||||
v_Y2 = v_round(v_fY0, v_fY1);
|
||||
}
|
||||
|
||||
// 12-15
|
||||
v_int32x4 v_X3, v_Y3;
|
||||
{
|
||||
v_float64x2 v_W = v_muladd(v_M6, v_x1, v_W0);
|
||||
v_W = v_select(v_W != v_zero, v_its / v_W, v_zero);
|
||||
v_float64x2 v_fX0 = v_max(v_intmin, v_min(v_intmax, v_muladd(v_M0, v_x1, v_X0d) * v_W));
|
||||
v_float64x2 v_fY0 = v_max(v_intmin, v_min(v_intmax, v_muladd(v_M3, v_x1, v_Y0d) * v_W));
|
||||
v_x1 += v_2;
|
||||
|
||||
v_W = v_muladd(v_M6, v_x1, v_W0);
|
||||
v_W = v_select(v_W != v_zero, v_its / v_W, v_zero);
|
||||
v_float64x2 v_fX1 = v_max(v_intmin, v_min(v_intmax, v_muladd(v_M0, v_x1, v_X0d) * v_W));
|
||||
v_float64x2 v_fY1 = v_max(v_intmin, v_min(v_intmax, v_muladd(v_M3, v_x1, v_Y0d) * v_W));
|
||||
v_x1 += v_2;
|
||||
|
||||
v_X3 = v_round(v_fX0, v_fX1);
|
||||
v_Y3 = v_round(v_fY0, v_fY1);
|
||||
}
|
||||
|
||||
// store alpha
|
||||
v_int32x4 v_alpha0 = ((v_Y0 & v_itsi1) << INTER_BITS) + (v_X0 & v_itsi1);
|
||||
v_int32x4 v_alpha1 = ((v_Y1 & v_itsi1) << INTER_BITS) + (v_X1 & v_itsi1);
|
||||
v_store((alpha + x1), v_pack(v_alpha0, v_alpha1));
|
||||
|
||||
v_alpha0 = ((v_Y2 & v_itsi1) << INTER_BITS) + (v_X2 & v_itsi1);
|
||||
v_alpha1 = ((v_Y3 & v_itsi1) << INTER_BITS) + (v_X3 & v_itsi1);
|
||||
v_store((alpha + x1 + 8), v_pack(v_alpha0, v_alpha1));
|
||||
|
||||
// convert to 16s
|
||||
v_X0 = v_reinterpret_as_s32(v_pack(v_X0 >> INTER_BITS, v_X1 >> INTER_BITS));
|
||||
v_X1 = v_reinterpret_as_s32(v_pack(v_X2 >> INTER_BITS, v_X3 >> INTER_BITS));
|
||||
v_Y0 = v_reinterpret_as_s32(v_pack(v_Y0 >> INTER_BITS, v_Y1 >> INTER_BITS));
|
||||
v_Y1 = v_reinterpret_as_s32(v_pack(v_Y2 >> INTER_BITS, v_Y3 >> INTER_BITS));
|
||||
|
||||
v_store_interleave(xy + x1 * 2, (v_reinterpret_as_s16)(v_X0), (v_reinterpret_as_s16)(v_Y0));
|
||||
v_store_interleave(xy + x1 * 2 + 16, (v_reinterpret_as_s16)(v_X1), (v_reinterpret_as_s16)(v_Y1));
|
||||
}
|
||||
|
||||
for( ; x1 < bw; x1++ )
|
||||
{
|
||||
double W = W0 + M[6]*x1;
|
||||
W = W ? INTER_TAB_SIZE/W : 0;
|
||||
double fX = std::max((double)INT_MIN, std::min((double)INT_MAX, (X0 + M[0]*x1)*W));
|
||||
double fY = std::max((double)INT_MIN, std::min((double)INT_MAX, (Y0 + M[3]*x1)*W));
|
||||
int X = saturate_cast<int>(fX);
|
||||
int Y = saturate_cast<int>(fY);
|
||||
|
||||
xy[x1*2] = saturate_cast<short>(X >> INTER_BITS);
|
||||
xy[x1*2+1] = saturate_cast<short>(Y >> INTER_BITS);
|
||||
alpha[x1] = (short)((Y & (INTER_TAB_SIZE-1))*INTER_TAB_SIZE +
|
||||
(X & (INTER_TAB_SIZE-1)));
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
class WarpPerspectiveInvoker :
|
||||
public ParallelLoopBody
|
||||
@ -2707,7 +2959,7 @@ public:
|
||||
{
|
||||
const int BLOCK_SZ = 32;
|
||||
short XY[BLOCK_SZ*BLOCK_SZ*2], A[BLOCK_SZ*BLOCK_SZ];
|
||||
int x, y, x1, y1, width = dst.cols, height = dst.rows;
|
||||
int x, y, y1, width = dst.cols, height = dst.rows;
|
||||
|
||||
int bh0 = std::min(BLOCK_SZ/2, height);
|
||||
int bw0 = std::min(BLOCK_SZ*BLOCK_SZ/bh0, width);
|
||||
@ -2738,14 +2990,15 @@ public:
|
||||
|
||||
if( interpolation == INTER_NEAREST )
|
||||
{
|
||||
x1 = 0;
|
||||
|
||||
#if CV_TRY_SSE4_1
|
||||
if (pwarp_impl_sse4)
|
||||
pwarp_impl_sse4->processNN(M, xy, X0, Y0, W0, bw);
|
||||
else
|
||||
#endif
|
||||
for( ; x1 < bw; x1++ )
|
||||
#if CV_SIMD128_64F
|
||||
WarpPerspectiveLine_ProcessNN_CV_SIMD(M, xy, X0, Y0, W0, bw);
|
||||
#else
|
||||
for( int x1 = 0; x1 < bw; x1++ )
|
||||
{
|
||||
double W = W0 + M[6]*x1;
|
||||
W = W ? 1./W : 0;
|
||||
@ -2757,18 +3010,21 @@ public:
|
||||
xy[x1*2] = saturate_cast<short>(X);
|
||||
xy[x1*2+1] = saturate_cast<short>(Y);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
else
|
||||
{
|
||||
short* alpha = A + y1*bw;
|
||||
x1 = 0;
|
||||
|
||||
#if CV_TRY_SSE4_1
|
||||
if (pwarp_impl_sse4)
|
||||
pwarp_impl_sse4->process(M, xy, alpha, X0, Y0, W0, bw);
|
||||
else
|
||||
#endif
|
||||
for( ; x1 < bw; x1++ )
|
||||
#if CV_SIMD128_64F
|
||||
WarpPerspectiveLine_Process_CV_SIMD(M, xy, alpha, X0, Y0, W0, bw);
|
||||
#else
|
||||
for( int x1 = 0; x1 < bw; x1++ )
|
||||
{
|
||||
double W = W0 + M[6]*x1;
|
||||
W = W ? INTER_TAB_SIZE/W : 0;
|
||||
@ -2782,6 +3038,7 @@ public:
|
||||
alpha[x1] = (short)((Y & (INTER_TAB_SIZE-1))*INTER_TAB_SIZE +
|
||||
(X & (INTER_TAB_SIZE-1)));
|
||||
}
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -50,6 +50,7 @@
|
||||
#ifndef OPENCV_IMGPROC_IMGWARP_HPP
|
||||
#define OPENCV_IMGPROC_IMGWARP_HPP
|
||||
#include "precomp.hpp"
|
||||
#include "opencv2/core/hal/intrin.hpp"
|
||||
|
||||
namespace cv
|
||||
{
|
||||
@ -78,6 +79,12 @@ public:
|
||||
};
|
||||
#endif
|
||||
}
|
||||
|
||||
#if CV_SIMD128_64F
|
||||
void WarpPerspectiveLine_ProcessNN_CV_SIMD(const double *M, short* xy, double X0, double Y0, double W0, int bw);
|
||||
void WarpPerspectiveLine_Process_CV_SIMD(const double *M, short* xy, short* alpha, double X0, double Y0, double W0, int bw);
|
||||
#endif
|
||||
|
||||
}
|
||||
#endif
|
||||
/* End of file. */
|
||||
|
||||
@ -77,6 +77,8 @@ Useful links:
|
||||
http://www.inf.ufrgs.br/~eslgastal/DomainTransform
|
||||
|
||||
https://www.learnopencv.com/non-photorealistic-rendering-using-opencv-python-c/
|
||||
|
||||
@defgroup photo_c C API
|
||||
@}
|
||||
*/
|
||||
|
||||
|
||||
@ -4,6 +4,7 @@
|
||||
#include <opencv2/core.hpp>
|
||||
#include <opencv2/imgproc.hpp>
|
||||
#include <opencv2/highgui.hpp>
|
||||
#include <opencv2/videoio.hpp>
|
||||
#include <opencv2/core/utils/trace.hpp>
|
||||
|
||||
using namespace cv;
|
||||
|
||||
@ -56,11 +56,6 @@ static void updateBrightnessContrast( int /*arg*/, void* )
|
||||
Scalar::all(0), -1, 8, 0 );
|
||||
imshow("histogram", histImage);
|
||||
}
|
||||
static void help()
|
||||
{
|
||||
std::cout << "\nThis program demonstrates the use of calcHist() -- histogram creation.\n"
|
||||
<< "Usage: \n" << "demhist [image_name -- Defaults to baboon.jpg]" << std::endl;
|
||||
}
|
||||
|
||||
const char* keys =
|
||||
{
|
||||
@ -70,9 +65,10 @@ const char* keys =
|
||||
int main( int argc, const char** argv )
|
||||
{
|
||||
CommandLineParser parser(argc, argv, keys);
|
||||
parser.about("\nThis program demonstrates the use of calcHist() -- histogram creation.\n");
|
||||
if (parser.has("help"))
|
||||
{
|
||||
help();
|
||||
parser.printMessage();
|
||||
return 0;
|
||||
}
|
||||
string inputImage = parser.get<string>(0);
|
||||
|
||||
@ -9,12 +9,11 @@
|
||||
using namespace cv;
|
||||
using namespace std;
|
||||
|
||||
static void help()
|
||||
static void help(const char ** argv)
|
||||
{
|
||||
printf("\nThis program demonstrated the use of the discrete Fourier transform (dft)\n"
|
||||
"The dft of an image is taken and it's power spectrum is displayed.\n"
|
||||
"Usage:\n"
|
||||
"./dft [image_name -- default lena.jpg]\n");
|
||||
"Usage:\n %s [image_name -- default lena.jpg]\n",argv[0]);
|
||||
}
|
||||
|
||||
const char* keys =
|
||||
@ -24,18 +23,18 @@ const char* keys =
|
||||
|
||||
int main(int argc, const char ** argv)
|
||||
{
|
||||
help();
|
||||
help(argv);
|
||||
CommandLineParser parser(argc, argv, keys);
|
||||
if (parser.has("help"))
|
||||
{
|
||||
help();
|
||||
help(argv);
|
||||
return 0;
|
||||
}
|
||||
string filename = parser.get<string>(0);
|
||||
Mat img = imread(samples::findFile(filename), IMREAD_GRAYSCALE);
|
||||
if( img.empty() )
|
||||
{
|
||||
help();
|
||||
help(argv);
|
||||
printf("Cannot read image file: %s\n", filename.c_str());
|
||||
return -1;
|
||||
}
|
||||
|
||||
@ -1,6 +1,7 @@
|
||||
#include "opencv2/objdetect.hpp"
|
||||
#include "opencv2/highgui.hpp"
|
||||
#include "opencv2/imgproc.hpp"
|
||||
#include "opencv2/videoio.hpp"
|
||||
#include <iostream>
|
||||
|
||||
using namespace std;
|
||||
|
||||
@ -14,15 +14,16 @@ struct ParamColorMap {
|
||||
};
|
||||
|
||||
String winName="False color";
|
||||
static const String ColorMaps[] = { "Autumn", "Bone", "Jet", "Winter", "Rainbow", "Ocean", "Summer",
|
||||
"Spring", "Cool", "HSV", "Pink", "Hot", "Parula", "User defined (random)"};
|
||||
static const String ColorMaps[] = { "Autumn", "Bone", "Jet", "Winter", "Rainbow", "Ocean", "Summer", "Spring",
|
||||
"Cool", "HSV", "Pink", "Hot", "Parula", "Magma", "Inferno", "Plasma", "Viridis",
|
||||
"Cividis", "Twilight", "Twilight Shifted", "Turbo", "User defined (random)" };
|
||||
|
||||
static void TrackColorMap(int x, void *r)
|
||||
{
|
||||
ParamColorMap *p = (ParamColorMap*)r;
|
||||
Mat dst;
|
||||
p->iColormap= x;
|
||||
if (x == COLORMAP_PARULA + 1)
|
||||
if (x == COLORMAP_TURBO + 1)
|
||||
{
|
||||
Mat lutRND(256, 1, CV_8UC3);
|
||||
randu(lutRND, Scalar(0, 0, 0), Scalar(255, 255, 255));
|
||||
@ -98,7 +99,7 @@ int main(int argc, char** argv)
|
||||
namedWindow(winName);
|
||||
createTrackbar("colormap", winName,&p.iColormap,1,TrackColorMap,(void*)&p);
|
||||
setTrackbarMin("colormap", winName, COLORMAP_AUTUMN);
|
||||
setTrackbarMax("colormap", winName, COLORMAP_PARULA+1);
|
||||
setTrackbarMax("colormap", winName, COLORMAP_TURBO+1);
|
||||
setTrackbarPos("colormap", winName, -1);
|
||||
|
||||
TrackColorMap(0, (void*)&p);
|
||||
|
||||
@ -8,13 +8,12 @@
|
||||
using namespace cv;
|
||||
using namespace std;
|
||||
|
||||
static void help()
|
||||
static void help( char** argv )
|
||||
{
|
||||
cout << "\nCool inpainging demo. Inpainting repairs damage to images by floodfilling the damage \n"
|
||||
<< "with surrounding image areas.\n"
|
||||
"Using OpenCV version %s\n" << CV_VERSION << "\n"
|
||||
"Usage:\n"
|
||||
"./inpaint [image_name -- Default fruits.jpg]\n" << endl;
|
||||
"Usage:\n" << argv[0] <<" [image_name -- Default fruits.jpg]\n" << endl;
|
||||
|
||||
cout << "Hot keys: \n"
|
||||
"\tESC - quit the program\n"
|
||||
@ -48,7 +47,7 @@ static void onMouse( int event, int x, int y, int flags, void* )
|
||||
int main( int argc, char** argv )
|
||||
{
|
||||
cv::CommandLineParser parser(argc, argv, "{@image|fruits.jpg|}");
|
||||
help();
|
||||
help(argv);
|
||||
|
||||
string filename = samples::findFile(parser.get<string>("@image"));
|
||||
Mat img0 = imread(filename, IMREAD_COLOR);
|
||||
|
||||
@ -31,9 +31,9 @@ public:
|
||||
// groupThreshold (set groupThreshold to 0 to turn off the grouping completely).
|
||||
vector<Rect> found;
|
||||
if (m == Default)
|
||||
hog.detectMultiScale(img, found, 0, Size(8,8), Size(32,32), 1.05, 2, false);
|
||||
hog.detectMultiScale(img, found, 0, Size(8,8), Size(), 1.05, 2, false);
|
||||
else if (m == Daimler)
|
||||
hog_d.detectMultiScale(img, found, 0.5, Size(8,8), Size(32,32), 1.05, 2, true);
|
||||
hog_d.detectMultiScale(img, found, 0, Size(8,8), Size(), 1.05, 2, true);
|
||||
return found;
|
||||
}
|
||||
void adjustRect(Rect & r) const
|
||||
@ -54,7 +54,7 @@ static const string keys = "{ help h | | print help message }"
|
||||
int main(int argc, char** argv)
|
||||
{
|
||||
CommandLineParser parser(argc, argv, keys);
|
||||
parser.about("This sample demonstrates the use ot the HoG descriptor.");
|
||||
parser.about("This sample demonstrates the use of the HoG descriptor.");
|
||||
if (parser.has("help"))
|
||||
{
|
||||
parser.printMessage();
|
||||
@ -114,7 +114,7 @@ int main(int argc, char** argv)
|
||||
imshow("People detector", frame);
|
||||
|
||||
// interact with user
|
||||
const char key = (char)waitKey(30);
|
||||
const char key = (char)waitKey(1);
|
||||
if (key == 27 || key == 'q') // ESC
|
||||
{
|
||||
cout << "Exit requested" << endl;
|
||||
|
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue
Block a user