Skip to content

O
opencv
Commit 2d6f35d6 authored by Roman Donchenko's avatar Roman Donchenko
Browse files
Options

Merge remote-tracking branch 'origin/2.4' into merge-2.4 

Conflicts:
	modules/gpuwarping/src/cuda/resize.cu
	modules/gpuwarping/src/resize.cpp
	modules/gpuwarping/test/test_resize.cpp
	modules/ocl/perf/main.cpp
	modules/ocl/perf/perf_calib3d.cpp
	modules/ocl/perf/perf_canny.cpp
	modules/ocl/perf/perf_color.cpp
	modules/ocl/perf/perf_haar.cpp
	modules/ocl/perf/perf_match_template.cpp
	modules/ocl/perf/perf_precomp.cpp
	modules/ocl/perf/perf_precomp.hpp
parents dd25f416 525b6eca
Expand all Hide whitespace changes
Inline Side-by-side
Showing with 734 additions and 935 deletions
CMakeLists.txt
View file @ 2d6f35d6
......@@ -460,6 +460,8 @@ include(cmake/OpenCVGenAndroidMK.cmake)
# Generate OpenCVСonfig.cmake and OpenCVConfig-version.cmake for cmake projects
include(cmake/OpenCVGenConfig.cmake)
# Generate Info.plist for the IOS framework
include(cmake/OpenCVGenInfoPlist.cmake)
# ----------------------------------------------------------------------------
# Summary:
......
cmake/OpenCVCRTLinkage.cmake
View file @ 2d6f35d6
......@@ -26,8 +26,8 @@ else()
set(HAVE_MSVC2012 TRUE)
endif()
TRY_COMPILE(HAVE_WINRT_SDK
"${OPENCV_BINARY_DIR}/CMakeFiles/CMakeTmp"
try_compile(HAVE_WINRT_SDK
"${OpenCV_BINARY_DIR}"
"${OpenCV_SOURCE_DIR}/cmake/checks/winrttest.cpp")
if (ENABLE_WINRT_MODE AND HAVE_WINRT_SDK AND HAVE_MSVC2012 AND HAVE_MSPDK)
......
cmake/OpenCVCompilerOptions.cmake
View file @ 2d6f35d6
......@@ -233,6 +233,10 @@ if(MSVC)
set(OPENCV_EXTRA_FLAGS "${OPENCV_EXTRA_FLAGS} /fp:fast") # !! important - be on the same wave with x64 compilers
endif()
endif()
if(OPENCV_WARNINGS_ARE_ERRORS)
set(OPENCV_EXTRA_FLAGS "${OPENCV_EXTRA_FLAGS} /WX")
endif()
endif()
# Extra link libs if the user selects building static libs:
......
cmake/OpenCVFindLibsGUI.cmake
View file @ 2d6f35d6
......@@ -5,12 +5,11 @@
#--- Win32 UI ---
ocv_clear_vars(HAVE_WIN32UI)
if(WITH_WIN32UI)
TRY_COMPILE(HAVE_WIN32UI
"${OPENCV_BINARY_DIR}/CMakeFiles/CMakeTmp"
try_compile(HAVE_WIN32UI
"${OpenCV_BINARY_DIR}"
"${OpenCV_SOURCE_DIR}/cmake/checks/win32uitest.cpp"
CMAKE_FLAGS "\"user32.lib\" \"gdi32.lib\""
OUTPUT_VARIABLE OUTPUT)
endif(WITH_WIN32UI)
CMAKE_FLAGS "-DLINK_LIBRARIES:STRING=user32;gdi32")
endif()
# --- QT4 ---
ocv_clear_vars(HAVE_QT HAVE_QT5)
......
cmake/OpenCVFindLibsGrfmt.cmake
View file @ 2d6f35d6
......@@ -149,7 +149,7 @@ if(WITH_JASPER)
endif()
# --- libpng (optional, should be searched after zlib) ---
if(WITH_PNG AND NOT IOS)
if(WITH_PNG)
if(BUILD_PNG)
ocv_clear_vars(PNG_FOUND)
else()
......
cmake/OpenCVFindLibsVideo.cmake
View file @ 2d6f35d6
......@@ -3,13 +3,12 @@
# ----------------------------------------------------------------------------
ocv_clear_vars(HAVE_VFW)
if (WITH_VFW)
TRY_COMPILE(HAVE_VFW
"${OPENCV_BINARY_DIR}/CMakeFiles/CMakeTmp"
if(WITH_VFW)
try_compile(HAVE_VFW
"${OpenCV_BINARY_DIR}"
"${OpenCV_SOURCE_DIR}/cmake/checks/vfwtest.cpp"
CMAKE_FLAGS "-DLINK_LIBRARIES:STRING=vfw32"
OUTPUT_VARIABLE OUTPUT)
endif(WITH_VFW)
CMAKE_FLAGS "-DLINK_LIBRARIES:STRING=vfw32")
endif(WITH_VFW)
# --- GStreamer ---
ocv_clear_vars(HAVE_GSTREAMER)
......@@ -271,8 +270,10 @@ if(WITH_AVFOUNDATION)
endif()
# --- QuickTime ---
if(WITH_QUICKTIME)
set(HAVE_QUICKTIME YES)
elseif(APPLE)
set(HAVE_QTKIT YES)
if (NOT IOS)
if(WITH_QUICKTIME)
set(HAVE_QUICKTIME YES)
elseif(APPLE)
set(HAVE_QTKIT YES)
endif()
endif()
cmake/OpenCVGenInfoPlist.cmake 0 → 100644
View file @ 2d6f35d6
if(IOS)
configure_file("${OpenCV_SOURCE_DIR}/platforms/ios/Info.plist.in"
"${CMAKE_BINARY_DIR}/ios/Info.plist")
endif()
cmake/OpenCVUtils.cmake
View file @ 2d6f35d6
......@@ -77,7 +77,7 @@ MACRO(ocv_check_compiler_flag LANG FLAG RESULT)
if(_fname)
MESSAGE(STATUS "Performing Test ${RESULT}")
TRY_COMPILE(${RESULT}
${CMAKE_BINARY_DIR}
"${CMAKE_BINARY_DIR}"
"${_fname}"
COMPILE_DEFINITIONS "${FLAG}"
OUTPUT_VARIABLE OUTPUT)
......
modules/contrib/src/inputoutput.cpp
View file @ 2d6f35d6
......@@ -136,7 +136,7 @@ namespace cv
char* fname;
#ifdef HAVE_WINRT
char fname_tmp[MAX_PATH];
size_t copied = wcstombs(fname, FindFileData.cFileName, MAX_PATH);
size_t copied = wcstombs(fname_tmp, FindFileData.cFileName, MAX_PATH);
CV_Assert((copied != MAX_PATH) && (copied != (size_t)-1));
fname = fname_tmp;
#else
......
modules/core/doc/basic_structures.rst
View file @ 2d6f35d6
......@@ -1369,7 +1369,7 @@ The method makes a new header for the specified row span of the matrix. Similarl
Mat::colRange
-------------
Creates a matrix header for the specified row span.
Creates a matrix header for the specified column span.
.. ocv:function:: Mat Mat::colRange(int startcol, int endcol) const
......
modules/core/src/parallel.cpp
View file @ 2d6f35d6
......@@ -144,9 +144,9 @@ namespace
{
cv::Range r;
r.start = (int)(wholeRange.start +
((size_t)sr.start*(wholeRange.end - wholeRange.start) + nstripes/2)/nstripes);
((uint64)sr.start*(wholeRange.end - wholeRange.start) + nstripes/2)/nstripes);
r.end = sr.end >= nstripes ? wholeRange.end : (int)(wholeRange.start +
((size_t)sr.end*(wholeRange.end - wholeRange.start) + nstripes/2)/nstripes);
((uint64)sr.end*(wholeRange.end - wholeRange.start) + nstripes/2)/nstripes);
(*body)(r);
}
cv::Range stripeRange() const { return cv::Range(0, nstripes); }
......
modules/gpuoptflow/src/tvl1flow.cpp
View file @ 2d6f35d6
......@@ -222,7 +222,8 @@ void cv::gpu::OpticalFlowDual_TVL1_GPU::procOneScale(const GpuMat& I0, const Gpu
{
estimateU(I1wx, I1wy, grad, rho_c, p11, p12, p21, p22, u1, u2, diff, l_t, static_cast<float>(theta));
error = gpu::sum(diff, norm_buf)[0];
if (epsilon > 0)
error = gpu::sum(diff, norm_buf)[0];
estimateDualVariables(u1, u2, p11, p12, p21, p22, taut);
}
......
modules/gpuwarping/src/cuda/resize.cu
View file @ 2d6f35d6
This diff is collapsed.
modules/gpuwarping/src/resize.cpp
View file @ 2d6f35d6
......@@ -50,18 +50,25 @@ void cv::gpu::resize(InputArray, OutputArray, Size, double, double, int, Stream&
namespace cv { namespace gpu { namespace cudev
{
namespace imgproc
{
template <typename T>
void resize_gpu(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float fx, float fy,
PtrStepSzb dst, int interpolation, cudaStream_t stream);
}
template <typename T>
void resize(const PtrStepSzb& src, const PtrStepSzb& srcWhole, int yoff, int xoff, const PtrStepSzb& dst, float fy, float fx, int interpolation, cudaStream_t stream);
}}}
void cv::gpu::resize(InputArray _src, OutputArray _dst, Size dsize, double fx, double fy, int interpolation, Stream& _stream)
void cv::gpu::resize(InputArray _src, OutputArray _dst, Size dsize, double fx, double fy, int interpolation, Stream& stream)
{
GpuMat src = _src.getGpuMat();
typedef void (*func_t)(const PtrStepSzb& src, const PtrStepSzb& srcWhole, int yoff, int xoff, const PtrStepSzb& dst, float fy, float fx, int interpolation, cudaStream_t stream);
static const func_t funcs[6][4] =
{
{cudev::resize<uchar> , 0 /*cudev::resize<uchar2>*/ , cudev::resize<uchar3> , cudev::resize<uchar4> },
{0 /*cudev::resize<schar>*/, 0 /*cudev::resize<char2>*/ , 0 /*cudev::resize<char3>*/, 0 /*cudev::resize<char4>*/},
{cudev::resize<ushort> , 0 /*cudev::resize<ushort2>*/, cudev::resize<ushort3> , cudev::resize<ushort4> },
{cudev::resize<short> , 0 /*cudev::resize<short2>*/ , cudev::resize<short3> , cudev::resize<short4> },
{0 /*cudev::resize<int>*/ , 0 /*cudev::resize<int2>*/ , 0 /*cudev::resize<int3>*/ , 0 /*cudev::resize<int4>*/ },
{cudev::resize<float> , 0 /*cudev::resize<float2>*/ , cudev::resize<float3> , cudev::resize<float4> }
};
CV_Assert( src.depth() <= CV_32F && src.channels() <= 4 );
CV_Assert( interpolation == INTER_NEAREST || interpolation == INTER_LINEAR || interpolation == INTER_CUBIC || interpolation == INTER_AREA );
CV_Assert( !(dsize == Size()) || (fx > 0 && fy > 0) );
......@@ -81,72 +88,21 @@ void cv::gpu::resize(InputArray _src, OutputArray _dst, Size dsize, double fx, d
if (dsize == src.size())
{
src.copyTo(dst, _stream);
src.copyTo(dst, stream);
return;
}
cudaStream_t stream = StreamAccessor::getStream(_stream);
const func_t func = funcs[src.depth()][src.channels() - 1];
if (!func)
CV_Error(Error::StsUnsupportedFormat, "Unsupported combination of source and destination types");
Size wholeSize;
Point ofs;
src.locateROI(wholeSize, ofs);
PtrStepSzb wholeSrc(wholeSize.height, wholeSize.width, src.datastart, src.step);
bool useNpp = (src.type() == CV_8UC1 || src.type() == CV_8UC4);
useNpp = useNpp && (interpolation == INTER_NEAREST || interpolation == INTER_LINEAR);
if (useNpp)
{
typedef NppStatus (*func_t)(const Npp8u * pSrc, NppiSize oSrcSize, int nSrcStep, NppiRect oSrcROI, Npp8u * pDst, int nDstStep, NppiSize dstROISize,
double xFactor, double yFactor, int eInterpolation);
const func_t funcs[4] = { nppiResize_8u_C1R, 0, 0, nppiResize_8u_C4R };
static const int npp_inter[] = {NPPI_INTER_NN, NPPI_INTER_LINEAR, NPPI_INTER_CUBIC, 0, NPPI_INTER_LANCZOS};
NppiSize srcsz;
srcsz.width = wholeSize.width;
srcsz.height = wholeSize.height;
NppiRect srcrect;
srcrect.x = ofs.x;
srcrect.y = ofs.y;
srcrect.width = src.cols;
srcrect.height = src.rows;
NppiSize dstsz;
dstsz.width = dst.cols;
dstsz.height = dst.rows;
NppStreamHandler h(stream);
nppSafeCall( funcs[src.channels() - 1](src.datastart, srcsz, static_cast<int>(src.step), srcrect,
dst.ptr<Npp8u>(), static_cast<int>(dst.step), dstsz, fx, fy, npp_inter[interpolation]) );
if (stream == 0)
cudaSafeCall( cudaDeviceSynchronize() );
}
else
{
using namespace ::cv::gpu::cudev::imgproc;
typedef void (*func_t)(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float fx, float fy, PtrStepSzb dst, int interpolation, cudaStream_t stream);
static const func_t funcs[6][4] =
{
{resize_gpu<uchar> , 0 /*resize_gpu<uchar2>*/ , resize_gpu<uchar3> , resize_gpu<uchar4> },
{0 /*resize_gpu<schar>*/, 0 /*resize_gpu<char2>*/ , 0 /*resize_gpu<char3>*/, 0 /*resize_gpu<char4>*/},
{resize_gpu<ushort> , 0 /*resize_gpu<ushort2>*/, resize_gpu<ushort3> , resize_gpu<ushort4> },
{resize_gpu<short> , 0 /*resize_gpu<short2>*/ , resize_gpu<short3> , resize_gpu<short4> },
{0 /*resize_gpu<int>*/ , 0 /*resize_gpu<int2>*/ , 0 /*resize_gpu<int3>*/ , 0 /*resize_gpu<int4>*/ },
{resize_gpu<float> , 0 /*resize_gpu<float2>*/ , resize_gpu<float3> , resize_gpu<float4> }
};
const func_t func = funcs[src.depth()][src.channels() - 1];
CV_Assert(func != 0);
func(src, PtrStepSzb(wholeSize.height, wholeSize.width, src.datastart, src.step), ofs.x, ofs.y,
static_cast<float>(1.0 / fx), static_cast<float>(1.0 / fy), dst, interpolation, stream);
}
func(src, wholeSrc, ofs.y, ofs.x, dst, static_cast<float>(1.0 / fy), static_cast<float>(1.0 / fx), interpolation, StreamAccessor::getStream(stream));
}
#endif // HAVE_CUDA
modules/gpuwarping/test/test_resize.cpp
View file @ 2d6f35d6
......@@ -155,7 +155,7 @@ GPU_TEST_P(Resize, Accuracy)
INSTANTIATE_TEST_CASE_P(GPU_Warping, Resize, testing::Combine(
ALL_DEVICES,
DIFFERENT_SIZES,
testing::Values(MatType(CV_8UC3), MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4), MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)),
testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4), MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4), MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)),
testing::Values(0.3, 0.5, 1.5, 2.0),
testing::Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR), Interpolation(cv::INTER_CUBIC)),
WHOLE_SUBMAT));
......@@ -201,50 +201,9 @@ GPU_TEST_P(ResizeSameAsHost, Accuracy)
INSTANTIATE_TEST_CASE_P(GPU_Warping, ResizeSameAsHost, testing::Combine(
ALL_DEVICES,
DIFFERENT_SIZES,
testing::Values(MatType(CV_8UC3), MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4), MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)),
testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4), MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4), MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)),
testing::Values(0.3, 0.5),
testing::Values(Interpolation(cv::INTER_AREA), Interpolation(cv::INTER_NEAREST)), //, Interpolation(cv::INTER_LINEAR), Interpolation(cv::INTER_CUBIC)
testing::Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_AREA)),
WHOLE_SUBMAT));
///////////////////////////////////////////////////////////////////
// Test NPP
PARAM_TEST_CASE(ResizeNPP, cv::gpu::DeviceInfo, MatType, double, Interpolation)
{
cv::gpu::DeviceInfo devInfo;
double coeff;
int interpolation;
int type;
virtual void SetUp()
{
devInfo = GET_PARAM(0);
type = GET_PARAM(1);
coeff = GET_PARAM(2);
interpolation = GET_PARAM(3);
cv::gpu::setDevice(devInfo.deviceID());
}
};
GPU_TEST_P(ResizeNPP, Accuracy)
{
cv::Mat src = readImageType("stereobp/aloe-L.png", type);
ASSERT_FALSE(src.empty());
cv::gpu::GpuMat dst;
cv::gpu::resize(loadMat(src), dst, cv::Size(), coeff, coeff, interpolation);
cv::Mat dst_gold;
resizeGold(src, dst_gold, coeff, coeff, interpolation);
EXPECT_MAT_SIMILAR(dst_gold, dst, 1e-1);
}
INSTANTIATE_TEST_CASE_P(GPU_Warping, ResizeNPP, testing::Combine(
ALL_DEVICES,
testing::Values(MatType(CV_8UC1), MatType(CV_8UC4)),
testing::Values(0.3, 0.5, 1.5, 2.0),
testing::Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR))));
#endif // HAVE_CUDA
modules/highgui/src/grfmt_png.cpp
View file @ 2d6f35d6
......@@ -171,7 +171,9 @@ bool PngDecoder::readHeader()
if( !m_buf.empty() || m_f )
{
png_uint_32 wdth, hght;
int bit_depth, color_type;
int bit_depth, color_type, num_trans=0;
png_bytep trans;
png_color_16p trans_values;
png_read_info( png_ptr, info_ptr );
......@@ -187,15 +189,22 @@ bool PngDecoder::readHeader()
{
switch(color_type)
{
case PNG_COLOR_TYPE_RGB:
case PNG_COLOR_TYPE_PALETTE:
m_type = CV_8UC3;
break;
case PNG_COLOR_TYPE_RGB_ALPHA:
m_type = CV_8UC4;
break;
default:
m_type = CV_8UC1;
case PNG_COLOR_TYPE_RGB:
m_type = CV_8UC3;
break;
case PNG_COLOR_TYPE_PALETTE:
png_get_tRNS( png_ptr, info_ptr, &trans, &num_trans, &trans_values);
//Check if there is a transparency value in the palette
if ( num_trans > 0 )
m_type = CV_8UC4;
else
m_type = CV_8UC3;
break;
case PNG_COLOR_TYPE_RGB_ALPHA:
m_type = CV_8UC4;
break;
default:
m_type = CV_8UC1;
}
if( bit_depth == 16 )
m_type = CV_MAKETYPE(CV_16U, CV_MAT_CN(m_type));
......
modules/highgui/test/test_grfmt.cpp
View file @ 2d6f35d6
......@@ -284,6 +284,98 @@ TEST(Highgui_ImreadVSCvtColor, regression)
EXPECT_LT(actual_avg_diff, MAX_MEAN_DIFF);
EXPECT_LT(actual_maxval, MAX_ABS_DIFF);
}
//Test OpenCV issue 3075 is solved
class CV_GrfmtReadPNGColorPaletteWithAlphaTest : public cvtest::BaseTest
{
public:
void run(int)
{
try
{
// First Test : Read PNG with alpha, imread flag -1
Mat img = imread(string(ts->get_data_path()) + "readwrite/color_palette_alpha.png",-1);
if (img.empty()) ts->set_failed_test_info(cvtest::TS::FAIL_INVALID_TEST_DATA);
ASSERT_TRUE(img.channels() == 4);
unsigned char* img_data = (unsigned char*)img.data;
// Verification first pixel is red in BGRA
ASSERT_TRUE(img_data[0] == 0x00);
ASSERT_TRUE(img_data[1] == 0x00);
ASSERT_TRUE(img_data[2] == 0xFF);
ASSERT_TRUE(img_data[3] == 0xFF);
// Verification second pixel is red in BGRA
ASSERT_TRUE(img_data[4] == 0x00);
ASSERT_TRUE(img_data[5] == 0x00);
ASSERT_TRUE(img_data[6] == 0xFF);
ASSERT_TRUE(img_data[7] == 0xFF);
// Second Test : Read PNG without alpha, imread flag -1
img = imread(string(ts->get_data_path()) + "readwrite/color_palette_no_alpha.png",-1);
if (img.empty()) ts->set_failed_test_info(cvtest::TS::FAIL_INVALID_TEST_DATA);
ASSERT_TRUE(img.channels() == 3);
img_data = (unsigned char*)img.data;
// Verification first pixel is red in BGR
ASSERT_TRUE(img_data[0] == 0x00);
ASSERT_TRUE(img_data[1] == 0x00);
ASSERT_TRUE(img_data[2] == 0xFF);
// Verification second pixel is red in BGR
ASSERT_TRUE(img_data[3] == 0x00);
ASSERT_TRUE(img_data[4] == 0x00);
ASSERT_TRUE(img_data[5] == 0xFF);
// Third Test : Read PNG with alpha, imread flag 1
img = imread(string(ts->get_data_path()) + "readwrite/color_palette_alpha.png",1);
if (img.empty()) ts->set_failed_test_info(cvtest::TS::FAIL_INVALID_TEST_DATA);
ASSERT_TRUE(img.channels() == 3);
img_data = (unsigned char*)img.data;
// Verification first pixel is red in BGR
ASSERT_TRUE(img_data[0] == 0x00);
ASSERT_TRUE(img_data[1] == 0x00);
ASSERT_TRUE(img_data[2] == 0xFF);
// Verification second pixel is red in BGR
ASSERT_TRUE(img_data[3] == 0x00);
ASSERT_TRUE(img_data[4] == 0x00);
ASSERT_TRUE(img_data[5] == 0xFF);
// Fourth Test : Read PNG without alpha, imread flag 1
img = imread(string(ts->get_data_path()) + "readwrite/color_palette_no_alpha.png",1);
if (img.empty()) ts->set_failed_test_info(cvtest::TS::FAIL_INVALID_TEST_DATA);
ASSERT_TRUE(img.channels() == 3);
img_data = (unsigned char*)img.data;
// Verification first pixel is red in BGR
ASSERT_TRUE(img_data[0] == 0x00);
ASSERT_TRUE(img_data[1] == 0x00);
ASSERT_TRUE(img_data[2] == 0xFF);
// Verification second pixel is red in BGR
ASSERT_TRUE(img_data[3] == 0x00);
ASSERT_TRUE(img_data[4] == 0x00);
ASSERT_TRUE(img_data[5] == 0xFF);
}
catch(...)
{
ts->set_failed_test_info(cvtest::TS::FAIL_EXCEPTION);
}
ts->set_failed_test_info(cvtest::TS::OK);
}
};
TEST(Highgui_Image, read_png_color_palette_with_alpha) { CV_GrfmtReadPNGColorPaletteWithAlphaTest test; test.safe_run(); }
#endif
#ifdef HAVE_JPEG
......
modules/ocl/perf/main.cpp
View file @ 2d6f35d6
......@@ -42,131 +42,54 @@
#include "perf_precomp.hpp"
static int cvErrorCallback(int /*status*/, const char * /*func_name*/,
const char *err_msg, const char * /*file_name*/,
int /*line*/, void * /*userdata*/)
const char * impls[] =
{
TestSystem::instance().printError(err_msg);
return 0;
}
int main(int argc, const char *argv[])
IMPL_OCL,
IMPL_PLAIN,
#ifdef HAVE_OPENCV_GPU
IMPL_GPU
#endif
};
int main(int argc, char ** argv)
{
const char *keys =
"{ h help | false | print help message }"
"{ f filter | | filter for test }"
"{ w workdir | | set working directory }"
"{ l list | false | show all tests }"
"{ d device | 0 | device id }"
"{ c cpu_ocl | false | use cpu as ocl device}"
"{ i iters | 10 | iteration count }"
"{ m warmup | 1 | gpu warm up iteration count}"
"{ t xtop | 1.1 | xfactor top boundary}"
"{ b xbottom | 0.9 | xfactor bottom boundary}"
"{ v verify | false | only run gpu once to verify if problems occur}";
const char * keys =
"{ h help | false | print help message }"
"{ t type | gpu | set device type:cpu or gpu}"
"{ p platform | 0 | set platform id }"
"{ d device | 0 | set device id }";
redirectError(cvErrorCallback);
CommandLineParser cmd(argc, argv, keys);
if (cmd.has("help"))
{
cout << "Avaible options:" << endl;
cout << "Available options besides google test option:" << endl;
cmd.printMessage();
return 0;
}
// get ocl devices
bool use_cpu = cmd.get<bool>("c");
vector<ocl::Info> oclinfo;
int num_devices = 0;
if(use_cpu)
num_devices = getDevice(oclinfo, ocl::CVCL_DEVICE_TYPE_CPU);
else
num_devices = getDevice(oclinfo);
if (num_devices < 1)
{
cerr << "no device found\n";
return -1;
}
// show device info
int devidx = 0;
for (size_t i = 0; i < oclinfo.size(); i++)
{
for (size_t j = 0; j < oclinfo[i].DeviceName.size(); j++)
{
cout << "device " << devidx++ << ": " << oclinfo[i].DeviceName[j] << endl;
}
}
string type = cmd.get<string>("type");
unsigned int pid = cmd.get<unsigned int>("platform");
int device = cmd.get<int>("device");
if (device < 0 || device >= num_devices)
{
cerr << "Invalid device ID" << endl;
return -1;
}
// set this to overwrite binary cache every time the test starts
ocl::setBinaryDiskCache(ocl::CACHE_UPDATE);
if (cmd.get<bool>("verify"))
{
TestSystem::instance().setNumIters(1);
TestSystem::instance().setGPUWarmupIters(0);
TestSystem::instance().setCPUIters(0);
}
devidx = 0;
for (size_t i = 0; i < oclinfo.size(); i++)
{
for (size_t j = 0; j < oclinfo[i].DeviceName.size(); j++, devidx++)
{
if (device == devidx)
{
ocl::setDevice(oclinfo[i], (int)j);
TestSystem::instance().setRecordName(oclinfo[i].DeviceName[j]);
cout << "use " << devidx << ": " <<oclinfo[i].DeviceName[j] << endl;
goto END_DEV;
}
}
}
END_DEV:
string filter = cmd.get<string>("filter");
string workdir = cmd.get<string>("workdir");
bool list = cmd.has("list");
int iters = cmd.get<int>("iters");
int wu_iters = cmd.get<int>("warmup");
double x_top = cmd.get<double>("xtop");
double x_bottom = cmd.get<double>("xbottom");
TestSystem::instance().setTopThreshold(x_top);
TestSystem::instance().setBottomThreshold(x_bottom);
int flag = type == "cpu" ? cv::ocl::CVCL_DEVICE_TYPE_CPU :
cv::ocl::CVCL_DEVICE_TYPE_GPU;
if (!filter.empty())
std::vector<cv::ocl::Info> oclinfo;
int devnums = cv::ocl::getDevice(oclinfo, flag);
if (devnums <= device || device < 0)
{
TestSystem::instance().setTestFilter(filter);
}
if (!workdir.empty())
{
if (workdir[workdir.size() - 1] != '/' && workdir[workdir.size() - 1] != '\\')
{
workdir += '/';
}
TestSystem::instance().setWorkingDir(workdir);
std::cout << "device invalid\n";
return -1;
}
if (list)
if (pid >= oclinfo.size())
{
TestSystem::instance().setListMode(true);
std::cout << "platform invalid\n";
return -1;
}
TestSystem::instance().setNumIters(iters);
TestSystem::instance().setGPUWarmupIters(wu_iters);
TestSystem::instance().run();
cv::ocl::setDevice(oclinfo[pid], device);
cv::ocl::setBinaryDiskCache(cv::ocl::CACHE_UPDATE);
return 0;
CV_PERF_TEST_MAIN_INTERNALS(ocl, impls)
}
modules/ocl/perf/perf_arithm.cpp
View file @ 2d6f35d6
This diff is collapsed.
modules/ocl/perf/perf_blend.cpp
View file @ 2d6f35d6
......@@ -45,9 +45,15 @@
//M*/
#include "perf_precomp.hpp"
using namespace perf;
///////////// blend ////////////////////////
template <typename T>
void blendLinearGold(const cv::Mat &img1, const cv::Mat &img2, const cv::Mat &weights1, const cv::Mat &weights2, cv::Mat &result_gold)
static void blendLinearGold(const cv::Mat &img1, const cv::Mat &img2,
const cv::Mat &weights1, const cv::Mat &weights2,
cv::Mat &result_gold)
{
result_gold.create(img1.size(), img1.type());
......@@ -63,60 +69,46 @@ void blendLinearGold(const cv::Mat &img1, const cv::Mat &img2, const cv::Mat &we
for (int x = 0; x < img1.cols * cn; ++x)
{
float w1 = weights1_row[x / cn];
float w2 = weights2_row[x / cn];
result_gold_row[x] = static_cast<T>((img1_row[x] * w1 + img2_row[x] * w2) / (w1 + w2 + 1e-5f));
int x1 = x * cn;
float w1 = weights1_row[x];
float w2 = weights2_row[x];
result_gold_row[x] = static_cast<T>((img1_row[x1] * w1
+ img2_row[x1] * w2) / (w1 + w2 + 1e-5f));
}
}
}
PERFTEST(blend)
typedef TestBaseWithParam<Size> blendLinearFixture;
PERF_TEST_P(blendLinearFixture, blendLinear, OCL_TYPICAL_MAT_SIZES)
{
Mat src1, src2, weights1, weights2, dst, ocl_dst;
ocl::oclMat d_src1, d_src2, d_weights1, d_weights2, d_dst;
const Size srcSize = GetParam();
const int type = CV_8UC1;
Mat src1(srcSize, type), src2(srcSize, CV_8UC1), dst;
Mat weights1(srcSize, CV_32FC1), weights2(srcSize, CV_32FC1);
int all_type[] = {CV_8UC1, CV_8UC4};
std::string type_name[] = {"CV_8UC1", "CV_8UC4"};
declare.in(src1, src2, WARMUP_RNG);
randu(weights1, 0.0f, 1.0f);
randu(weights2, 0.0f, 1.0f);
for (int size = Min_Size; size <= Max_Size; size *= Multiple)
if (RUN_OCL_IMPL)
{
for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++)
{
SUBTEST << size << 'x' << size << "; " << type_name[j] << " and CV_32FC1";
gen(src1, size, size, all_type[j], 0, 256);
gen(src2, size, size, all_type[j], 0, 256);
gen(weights1, size, size, CV_32FC1, 0, 1);
gen(weights2, size, size, CV_32FC1, 0, 1);
blendLinearGold<uchar>(src1, src2, weights1, weights2, dst);
CPU_ON;
blendLinearGold<uchar>(src1, src2, weights1, weights2, dst);
CPU_OFF;
d_src1.upload(src1);
d_src2.upload(src2);
d_weights1.upload(weights1);
d_weights2.upload(weights2);
WARMUP_ON;
ocl::blendLinear(d_src1, d_src2, d_weights1, d_weights2, d_dst);
WARMUP_OFF;
GPU_ON;
ocl::blendLinear(d_src1, d_src2, d_weights1, d_weights2, d_dst);
GPU_OFF;
GPU_FULL_ON;
d_src1.upload(src1);
d_src2.upload(src2);
d_weights1.upload(weights1);
d_weights2.upload(weights2);
ocl::blendLinear(d_src1, d_src2, d_weights1, d_weights2, d_dst);
d_dst.download(ocl_dst);
GPU_FULL_OFF;
TestSystem::instance().ExpectedMatNear(dst, ocl_dst, 1.f);
}
ocl::oclMat oclSrc1(src1), oclSrc2(src2), oclDst;
ocl::oclMat oclWeights1(weights1), oclWeights2(weights2);
TEST_CYCLE() cv::ocl::blendLinear(oclSrc1, oclSrc2, oclWeights1, oclWeights2, oclDst);
oclDst.download(dst);
SANITY_CHECK(dst);
}
else if (RUN_PLAIN_IMPL)
{
TEST_CYCLE() blendLinearGold<uchar>(src1, src2, weights1, weights2, dst);
SANITY_CHECK(dst);
}
else
OCL_PERF_ELSE
}
modules/ocl/perf/perf_brute_force_matcher.cpp
View file @ 2d6f35d6
......@@ -45,123 +45,119 @@
//M*/
#include "perf_precomp.hpp"
//////////////////// BruteForceMatch /////////////////
PERFTEST(BruteForceMatcher)
{
Mat trainIdx_cpu;
Mat distance_cpu;
Mat allDist_cpu;
Mat nMatches_cpu;
for (int size = Min_Size; size <= Max_Size; size *= Multiple)
{
// Init CPU matcher
int desc_len = 64;
BFMatcher matcher(NORM_L2);
Mat query;
gen(query, size, desc_len, CV_32F, 0, 1);
Mat train;
gen(train, size, desc_len, CV_32F, 0, 1);
// Output
vector< vector<DMatch> > matches(2);
vector< vector<DMatch> > d_matches(2);
// Init GPU matcher
ocl::BruteForceMatcher_OCL_base d_matcher(ocl::BruteForceMatcher_OCL_base::L2Dist);
using namespace perf;
ocl::oclMat d_query(query);
ocl::oclMat d_train(train);
#define OCL_BFMATCHER_TYPICAL_MAT_SIZES ::testing::Values(cv::Size(128, 500), cv::Size(128, 1000), cv::Size(128, 2000))
ocl::oclMat d_trainIdx, d_distance, d_allDist, d_nMatches;
SUBTEST << size << "; match";
matcher.match(query, train, matches[0]);
//////////////////// BruteForceMatch /////////////////
CPU_ON;
matcher.match(query, train, matches[0]);
CPU_OFF;
typedef TestBaseWithParam<Size> BruteForceMatcherFixture;
WARMUP_ON;
d_matcher.matchSingle(d_query, d_train, d_trainIdx, d_distance);
WARMUP_OFF;
PERF_TEST_P(BruteForceMatcherFixture, DISABLED_match,
OCL_BFMATCHER_TYPICAL_MAT_SIZES) // TODO too big difference between implementations
{
const Size srcSize = GetParam();
GPU_ON;
d_matcher.matchSingle(d_query, d_train, d_trainIdx, d_distance);
GPU_OFF;
vector<DMatch> matches;
Mat query(srcSize, CV_32F), train(srcSize, CV_32F);
declare.in(query, train).time(srcSize.height == 2000 ? 8 : 4 );
randu(query, 0.0f, 1.0f);
randu(train, 0.0f, 1.0f);
GPU_FULL_ON;
d_query.upload(query);
d_train.upload(train);
d_matcher.match(d_query, d_train, d_matches[0]);
GPU_FULL_OFF;
if (RUN_PLAIN_IMPL)
{
BFMatcher matcher(NORM_L2);
TEST_CYCLE() matcher.match(query, train, matches);
int diff = abs((int)d_matches[0].size() - (int)matches[0].size());
if(diff == 0)
TestSystem::instance().setAccurate(1, 0);
else
TestSystem::instance().setAccurate(0, diff);
SANITY_CHECK_MATCHES(matches);
}
else if (RUN_OCL_IMPL)
{
ocl::BruteForceMatcher_OCL_base oclMatcher(ocl::BruteForceMatcher_OCL_base::L2Dist);
ocl::oclMat oclQuery(query), oclTrain(train);
SUBTEST << size << "; knnMatch";
TEST_CYCLE() oclMatcher.match(oclQuery, oclTrain, matches);
matcher.knnMatch(query, train, matches, 2);
SANITY_CHECK_MATCHES(matches);
}
else
OCL_PERF_ELSE
}
CPU_ON;
matcher.knnMatch(query, train, matches, 2);
CPU_OFF;
PERF_TEST_P(BruteForceMatcherFixture, DISABLED_knnMatch,
OCL_BFMATCHER_TYPICAL_MAT_SIZES) // TODO too many outliers
{
const Size srcSize = GetParam();
WARMUP_ON;
d_matcher.knnMatchSingle(d_query, d_train, d_trainIdx, d_distance, d_allDist, 2);
WARMUP_OFF;
vector<vector<DMatch> > matches(2);
Mat query(srcSize, CV_32F), train(srcSize, CV_32F);
randu(query, 0.0f, 1.0f);
randu(train, 0.0f, 1.0f);
GPU_ON;
d_matcher.knnMatchSingle(d_query, d_train, d_trainIdx, d_distance, d_allDist, 2);
GPU_OFF;
declare.in(query, train);
if (srcSize.height == 2000)
declare.time(8);
GPU_FULL_ON;
d_query.upload(query);
d_train.upload(train);
d_matcher.knnMatch(d_query, d_train, d_matches, 2);
GPU_FULL_OFF;
if (RUN_PLAIN_IMPL)
{
BFMatcher matcher (NORM_L2);
TEST_CYCLE() matcher.knnMatch(query, train, matches, 2);
diff = abs((int)d_matches[0].size() - (int)matches[0].size());
if(diff == 0)
TestSystem::instance().setAccurate(1, 0);
else
TestSystem::instance().setAccurate(0, diff);
std::vector<DMatch> & matches0 = matches[0], & matches1 = matches[1];
SANITY_CHECK_MATCHES(matches0);
SANITY_CHECK_MATCHES(matches1);
}
else if (RUN_OCL_IMPL)
{
ocl::BruteForceMatcher_OCL_base oclMatcher(ocl::BruteForceMatcher_OCL_base::L2Dist);
ocl::oclMat oclQuery(query), oclTrain(train);
SUBTEST << size << "; radiusMatch";
TEST_CYCLE() oclMatcher.knnMatch(oclQuery, oclTrain, matches, 2);
float max_distance = 2.0f;
std::vector<DMatch> & matches0 = matches[0], & matches1 = matches[1];
SANITY_CHECK_MATCHES(matches0);
SANITY_CHECK_MATCHES(matches1);
}
else
OCL_PERF_ELSE
}
matcher.radiusMatch(query, train, matches, max_distance);
PERF_TEST_P(BruteForceMatcherFixture, DISABLED_radiusMatch,
OCL_BFMATCHER_TYPICAL_MAT_SIZES) // TODO too many outliers
{
const Size srcSize = GetParam();
CPU_ON;
matcher.radiusMatch(query, train, matches, max_distance);
CPU_OFF;
const float max_distance = 2.0f;
vector<vector<DMatch> > matches(2);
Mat query(srcSize, CV_32F), train(srcSize, CV_32F);
declare.in(query, train);
Mat trainIdx, distance, allDist;
d_trainIdx.release();
randu(query, 0.0f, 1.0f);
randu(train, 0.0f, 1.0f);
WARMUP_ON;
d_matcher.radiusMatchSingle(d_query, d_train, d_trainIdx, d_distance, d_nMatches, max_distance);
WARMUP_OFF;
if (RUN_PLAIN_IMPL)
{
BFMatcher matcher (NORM_L2);
TEST_CYCLE() matcher.radiusMatch(query, matches, max_distance);
GPU_ON;
d_matcher.radiusMatchSingle(d_query, d_train, d_trainIdx, d_distance, d_nMatches, max_distance);
GPU_OFF;
std::vector<DMatch> & matches0 = matches[0], & matches1 = matches[1];
SANITY_CHECK_MATCHES(matches0);
SANITY_CHECK_MATCHES(matches1);
}
else if (RUN_OCL_IMPL)
{
ocl::oclMat oclQuery(query), oclTrain(train);
ocl::BruteForceMatcher_OCL_base oclMatcher(ocl::BruteForceMatcher_OCL_base::L2Dist);
GPU_FULL_ON;
d_query.upload(query);
d_train.upload(train);
d_matcher.radiusMatch(d_query, d_train, d_matches, max_distance);
GPU_FULL_OFF;
TEST_CYCLE() oclMatcher.radiusMatch(oclQuery, oclTrain, matches, max_distance);
diff = abs((int)d_matches[0].size() - (int)matches[0].size());
if(diff == 0)
TestSystem::instance().setAccurate(1, 0);
else
TestSystem::instance().setAccurate(0, diff);
std::vector<DMatch> & matches0 = matches[0], & matches1 = matches[1];
SANITY_CHECK_MATCHES(matches0);
SANITY_CHECK_MATCHES(matches1);
}
else
OCL_PERF_ELSE
}
#undef OCL_BFMATCHER_TYPICAL_MAT_SIZES
modules/ocl/perf/perf_calib3d.cpp
View file @ 2d6f35d6
......@@ -45,48 +45,44 @@
//M*/
#include "perf_precomp.hpp"
///////////// StereoMatchBM ////////////////////////
PERFTEST(StereoMatchBM)
{
Mat left_image = imread(abspath("aloeL.jpg"), cv::IMREAD_GRAYSCALE);
Mat right_image = imread(abspath("aloeR.jpg"), cv::IMREAD_GRAYSCALE);
Mat disp,dst;
ocl::oclMat d_left, d_right,d_disp;
int n_disp= 128;
int winSize =19;
SUBTEST << left_image.cols << 'x' << left_image.rows << "; aloeL.jpg ;"<< right_image.cols << 'x' << right_image.rows << "; aloeR.jpg ";
PERF_TEST(StereoMatchBMFixture, DISABLED_StereoMatchBM) // TODO doesn't work properly
{
Mat left_image = imread(getDataPath("gpu/stereobm/aloe-L.png"), cv::IMREAD_GRAYSCALE);
Mat right_image = imread(getDataPath("gpu/stereobm/aloe-R.png"), cv::IMREAD_GRAYSCALE);
Ptr<StereoBM> bm = createStereoBM(n_disp, winSize);
bm->compute(left_image, right_image, dst);
ASSERT_TRUE(!left_image.empty()) << "no input image";
ASSERT_TRUE(!right_image.empty()) << "no input image";
ASSERT_TRUE(right_image.size() == left_image.size());
ASSERT_TRUE(right_image.size() == left_image.size());
CPU_ON;
bm->compute(left_image, right_image, dst);
CPU_OFF;
const int n_disp = 128, winSize = 19;
Mat disp(left_image.size(), CV_16SC1);
d_left.upload(left_image);
d_right.upload(right_image);
declare.in(left_image, right_image).out(disp);
ocl::StereoBM_OCL d_bm(0, n_disp, winSize);
if (RUN_OCL_IMPL)
{
ocl::oclMat oclLeft(left_image), oclRight(right_image),
oclDisp(left_image.size(), CV_16SC1);
ocl::StereoBM_OCL oclBM(0, n_disp, winSize);
WARMUP_ON;
d_bm(d_left, d_right, d_disp);
WARMUP_OFF;
TEST_CYCLE() oclBM(oclLeft, oclRight, oclDisp);
cv::Mat ocl_mat;
d_disp.download(ocl_mat);
ocl_mat.convertTo(ocl_mat, dst.type());
oclDisp.download(disp);
GPU_ON;
d_bm(d_left, d_right, d_disp);
GPU_OFF;
SANITY_CHECK(disp);
}
else if (RUN_PLAIN_IMPL)
{
Ptr<StereoBM> bm = createStereoBM(n_disp, winSize);
GPU_FULL_ON;
d_left.upload(left_image);
d_right.upload(right_image);
d_bm(d_left, d_right, d_disp);
d_disp.download(disp);
GPU_FULL_OFF;
TEST_CYCLE() bm->compute(left_image, right_image, disp);
TestSystem::instance().setAccurate(-1, 0.);
SANITY_CHECK(disp);
}
else
OCL_PERF_ELSE
}
modules/ocl/perf/perf_canny.cpp
View file @ 2d6f35d6
......@@ -45,41 +45,33 @@
//M*/
#include "perf_precomp.hpp"
///////////// Canny ////////////////////////
PERFTEST(Canny)
{
Mat img = imread(abspath("aloeL.jpg"), IMREAD_GRAYSCALE);
if (img.empty())
{
throw runtime_error("can't open aloeL.jpg");
}
SUBTEST << img.cols << 'x' << img.rows << "; aloeL.jpg" << "; edges" << "; CV_8UC1";
using namespace perf;
Mat edges(img.size(), CV_8UC1), ocl_edges;
///////////// Canny ////////////////////////
CPU_ON;
Canny(img, edges, 50.0, 100.0);
CPU_OFF;
PERF_TEST(CannyFixture, DISABLED_Canny) // TODO difference between implmentations
{
Mat img = imread(getDataPath("gpu/stereobm/aloe-L.png"), cv::IMREAD_GRAYSCALE),
edges(img.size(), CV_8UC1);
ASSERT_TRUE(!img.empty()) << "can't open aloe-L.png";
ocl::oclMat d_img(img);
ocl::oclMat d_edges;
ocl::CannyBuf d_buf;
declare.in(img).out(edges);
WARMUP_ON;
ocl::Canny(d_img, d_buf, d_edges, 50.0, 100.0);
WARMUP_OFF;
if (RUN_OCL_IMPL)
{
ocl::oclMat oclImg(img), oclEdges(img.size(), CV_8UC1);
GPU_ON;
ocl::Canny(d_img, d_buf, d_edges, 50.0, 100.0);
GPU_OFF;
TEST_CYCLE() ocl::Canny(oclImg, oclEdges, 50.0, 100.0);
oclEdges.download(edges);
GPU_FULL_ON;
d_img.upload(img);
ocl::Canny(d_img, d_buf, d_edges, 50.0, 100.0);
d_edges.download(ocl_edges);
GPU_FULL_OFF;
SANITY_CHECK(edges);
}
else if (RUN_PLAIN_IMPL)
{
TEST_CYCLE() Canny(img, edges, 50.0, 100.0);
TestSystem::instance().ExceptedMatSimilar(edges, ocl_edges, 2e-2);
SANITY_CHECK(edges);
}
else
OCL_PERF_ELSE
}
modules/ocl/perf/perf_color.cpp
View file @ 2d6f35d6
......@@ -45,49 +45,34 @@
//M*/
#include "perf_precomp.hpp"
///////////// cvtColor////////////////////////
PERFTEST(cvtColor)
{
Mat src, dst, ocl_dst;
ocl::oclMat d_src, d_dst;
int all_type[] = {CV_8UC4};
std::string type_name[] = {"CV_8UC4"};
for (int size = Min_Size; size <= Max_Size; size *= Multiple)
{
for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++)
{
gen(src, size, size, all_type[j], 0, 256);
SUBTEST << size << "x" << size << "; " << type_name[j] << " ; CV_RGBA2GRAY";
cvtColor(src, dst, COLOR_RGBA2GRAY, 4);
CPU_ON;
cvtColor(src, dst, COLOR_RGBA2GRAY, 4);
CPU_OFF;
using namespace perf;
d_src.upload(src);
///////////// cvtColor////////////////////////
WARMUP_ON;
ocl::cvtColor(d_src, d_dst, COLOR_RGBA2GRAY, 4);
WARMUP_OFF;
typedef TestBaseWithParam<Size> cvtColorFixture;
GPU_ON;
ocl::cvtColor(d_src, d_dst, COLOR_RGBA2GRAY, 4);
GPU_OFF;
PERF_TEST_P(cvtColorFixture, cvtColor, OCL_TYPICAL_MAT_SIZES)
{
const Size srcSize = GetParam();
GPU_FULL_ON;
d_src.upload(src);
ocl::cvtColor(d_src, d_dst, COLOR_RGBA2GRAY, 4);
d_dst.download(ocl_dst);
GPU_FULL_OFF;
Mat src(srcSize, CV_8UC4), dst(srcSize, CV_8UC4);
declare.in(src, WARMUP_RNG).out(dst);
TestSystem::instance().ExceptedMatSimilar(dst, ocl_dst, 1e-5);
}
if (RUN_OCL_IMPL)
{
ocl::oclMat oclSrc(src), oclDst(src.size(), CV_8UC4);
TEST_CYCLE() ocl::cvtColor(oclSrc, oclDst, COLOR_RGBA2GRAY, 4);
oclDst.download(dst);
SANITY_CHECK(dst);
}
else if (RUN_PLAIN_IMPL)
{
TEST_CYCLE() cv::cvtColor(src, dst, COLOR_RGBA2GRAY, 4);
SANITY_CHECK(dst);
}
else
OCL_PERF_ELSE
}
modules/ocl/perf/perf_fft.cpp
View file @ 2d6f35d6
......@@ -45,47 +45,39 @@
//M*/
#include "perf_precomp.hpp"
///////////// dft ////////////////////////
PERFTEST(dft)
{
Mat src, dst, ocl_dst;
ocl::oclMat d_src, d_dst;
int all_type[] = {CV_32FC2};
std::string type_name[] = {"CV_32FC2"};
using namespace perf;
for (int size = Min_Size; size <= Max_Size; size *= Multiple)
{
for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++)
{
SUBTEST << size << 'x' << size << "; " << type_name[j] << " ; complex-to-complex";
///////////// dft ////////////////////////
gen(src, size, size, all_type[j], Scalar::all(0), Scalar::all(1));
typedef TestBaseWithParam<Size> dftFixture;
dft(src, dst);
PERF_TEST_P(dftFixture, DISABLED_dft, OCL_TYPICAL_MAT_SIZES) // TODO not implemented
{
const Size srcSize = GetParam();
CPU_ON;
dft(src, dst);
CPU_OFF;
Mat src(srcSize, CV_32FC2), dst;
randu(src, 0.0f, 1.0f);
declare.in(src);
d_src.upload(src);
if (srcSize == OCL_SIZE_4000)
declare.time(7.4);
WARMUP_ON;
ocl::dft(d_src, d_dst, Size(size, size));
WARMUP_OFF;
if (RUN_OCL_IMPL)
{
ocl::oclMat oclSrc(src), oclDst;
GPU_ON;
ocl::dft(d_src, d_dst, Size(size, size));
GPU_OFF;
TEST_CYCLE() cv::ocl::dft(oclSrc, oclDst);
GPU_FULL_ON;
d_src.upload(src);
ocl::dft(d_src, d_dst, Size(size, size));
d_dst.download(ocl_dst);
GPU_FULL_OFF;
oclDst.download(dst);
TestSystem::instance().ExpectedMatNear(dst, ocl_dst, src.size().area() * 1e-4);
}
SANITY_CHECK(dst);
}
else if (RUN_PLAIN_IMPL)
{
TEST_CYCLE() cv::dft(src, dst);
SANITY_CHECK(dst);
}
else
OCL_PERF_ELSE
}
modules/ocl/perf/perf_filters.cpp
View file @ 2d6f35d6
This diff is collapsed.
modules/ocl/perf/perf_gemm.cpp
View file @ 2d6f35d6
......@@ -45,46 +45,40 @@
//M*/
#include "perf_precomp.hpp"
///////////// gemm ////////////////////////
PERFTEST(gemm)
{
Mat src1, src2, src3, dst, ocl_dst;
ocl::oclMat d_src1, d_src2, d_src3, d_dst;
using namespace perf;
for (int size = Min_Size; size <= Max_Size; size *= Multiple)
{
SUBTEST << size << 'x' << size;
///////////// gemm ////////////////////////
gen(src1, size, size, CV_32FC1, Scalar::all(-10), Scalar::all(10));
gen(src2, size, size, CV_32FC1, Scalar::all(-10), Scalar::all(10));
gen(src3, size, size, CV_32FC1, Scalar::all(-10), Scalar::all(10));
typedef TestBaseWithParam<Size> gemmFixture;
gemm(src1, src2, 1.0, src3, 1.0, dst);
PERF_TEST_P(gemmFixture, DISABLED_gemm, OCL_TYPICAL_MAT_SIZES) // TODO not implemented
{
const Size srcSize = GetParam();
CPU_ON;
gemm(src1, src2, 1.0, src3, 1.0, dst);
CPU_OFF;
Mat src1(srcSize, CV_32FC1), src2(srcSize, CV_32FC1),
src3(srcSize, CV_32FC1), dst(srcSize, CV_32FC1);
declare.in(src1, src2, src3).out(dst);
randu(src1, -10.0f, 10.0f);
randu(src2, -10.0f, 10.0f);
randu(src3, -10.0f, 10.0f);
d_src1.upload(src1);
d_src2.upload(src2);
d_src3.upload(src3);
if (RUN_OCL_IMPL)
{
ocl::oclMat oclSrc1(src1), oclSrc2(src2),
oclSrc3(src3), oclDst(srcSize, CV_32FC1);
WARMUP_ON;
ocl::gemm(d_src1, d_src2, 1.0, d_src3, 1.0, d_dst);
WARMUP_OFF;
TEST_CYCLE() cv::ocl::gemm(oclSrc1, oclSrc2, 1.0, oclSrc3, 1.0, oclDst);
GPU_ON;
ocl::gemm(d_src1, d_src2, 1.0, d_src3, 1.0, d_dst);
GPU_OFF;
oclDst.download(dst);
GPU_FULL_ON;
d_src1.upload(src1);
d_src2.upload(src2);
d_src3.upload(src3);
ocl::gemm(d_src1, d_src2, 1.0, d_src3, 1.0, d_dst);
d_dst.download(ocl_dst);
GPU_FULL_OFF;
SANITY_CHECK(dst);
}
else if (RUN_PLAIN_IMPL)
{
TEST_CYCLE() cv::gemm(src1, src2, 1.0, src3, 1.0, dst);
TestSystem::instance().ExpectedMatNear(ocl_dst, dst, src1.cols * src1.rows * 1e-4);
SANITY_CHECK(dst);
}
else
OCL_PERF_ELSE
}
modules/ocl/perf/perf_gftt.cpp
View file @ 2d6f35d6
......@@ -46,56 +46,50 @@
#include "perf_precomp.hpp"
///////////// GoodFeaturesToTrack ////////////////////////
PERFTEST(GoodFeaturesToTrack)
{
using namespace cv;
int maxCorners = 2000;
double qualityLevel = 0.01;
using namespace perf;
using std::tr1::tuple;
using std::tr1::get;
std::string images[] = { "rubberwhale1.png", "aloeL.jpg" };
std::vector<cv::Point2f> pts_gold, pts_ocl;
for(size_t imgIdx = 0; imgIdx < (sizeof(images)/sizeof(std::string)); ++imgIdx)
{
Mat frame = imread(abspath(images[imgIdx]), IMREAD_GRAYSCALE);
CV_Assert(!frame.empty());
///////////// GoodFeaturesToTrack ////////////////////////
for(float minDistance = 0; minDistance < 4; minDistance += 3.0)
{
SUBTEST << "image = " << images[imgIdx] << "; ";
SUBTEST << "minDistance = " << minDistance << "; ";
typedef tuple<string, double> GoodFeaturesToTrackParams;
typedef TestBaseWithParam<GoodFeaturesToTrackParams> GoodFeaturesToTrackFixture;
cv::goodFeaturesToTrack(frame, pts_gold, maxCorners, qualityLevel, minDistance);
PERF_TEST_P(GoodFeaturesToTrackFixture, GoodFeaturesToTrack,
::testing::Combine(::testing::Values(string("gpu/opticalflow/rubberwhale1.png"),
string("gpu/stereobm/aloe-L.png")),
::testing::Range(0.0, 4.0, 3.0)))
{
CPU_ON;
cv::goodFeaturesToTrack(frame, pts_gold, maxCorners, qualityLevel, minDistance);
CPU_OFF;
const GoodFeaturesToTrackParams param = GetParam();
const string fileName = getDataPath(get<0>(param));
const int maxCorners = 2000;
const double qualityLevel = 0.01, minDistance = get<1>(param);
cv::ocl::GoodFeaturesToTrackDetector_OCL detector(maxCorners, qualityLevel, minDistance);
Mat frame = imread(fileName, IMREAD_GRAYSCALE);
ASSERT_TRUE(!frame.empty()) << "no input image";
ocl::oclMat frame_ocl(frame), pts_oclmat;
vector<Point2f> pts_gold;
declare.in(frame);
WARMUP_ON;
detector(frame_ocl, pts_oclmat);
WARMUP_OFF;
if (RUN_OCL_IMPL)
{
ocl::oclMat oclFrame(frame), pts_oclmat;
ocl::GoodFeaturesToTrackDetector_OCL detector(maxCorners, qualityLevel, minDistance);
detector.downloadPoints(pts_oclmat, pts_ocl);
TEST_CYCLE() detector(oclFrame, pts_oclmat);
double diff = abs(static_cast<float>(pts_gold.size() - pts_ocl.size()));
TestSystem::instance().setAccurate(diff == 0.0, diff);
detector.downloadPoints(pts_oclmat, pts_gold);
GPU_ON;
detector(frame_ocl, pts_oclmat);
GPU_OFF;
SANITY_CHECK(pts_gold);
}
else if (RUN_PLAIN_IMPL)
{
TEST_CYCLE() cv::goodFeaturesToTrack(frame, pts_gold,
maxCorners, qualityLevel, minDistance);
GPU_FULL_ON;
frame_ocl.upload(frame);
detector(frame_ocl, pts_oclmat);
detector.downloadPoints(pts_oclmat, pts_ocl);
GPU_FULL_OFF;
}
SANITY_CHECK(pts_gold);
}
else
OCL_PERF_ELSE
}
modules/ocl/perf/perf_haar.cpp
View file @ 2d6f35d6
......@@ -45,63 +45,44 @@
//M*/
#include "perf_precomp.hpp"
///////////// Haar ////////////////////////
PERFTEST(Haar)
{
Mat img = imread(abspath("basketball1.png"), IMREAD_GRAYSCALE);
#include "opencv2/objdetect/objdetect_c.h"
if (img.empty())
{
throw runtime_error("can't open basketball1.png");
}
using namespace perf;
CascadeClassifier faceCascadeCPU;
if (!faceCascadeCPU.load(abspath("haarcascade_frontalface_alt.xml")))
{
throw runtime_error("can't load haarcascade_frontalface_alt.xml");
}
///////////// Haar ////////////////////////
PERF_TEST(HaarFixture, Haar)
{
vector<Rect> faces;
SUBTEST << img.cols << "x" << img.rows << "; scale image";
CPU_ON;
faceCascadeCPU.detectMultiScale(img, faces,
1.1, 2, 0 | CASCADE_SCALE_IMAGE, Size(30, 30));
CPU_OFF;
Mat img = imread(getDataPath("gpu/haarcascade/basketball1.png"), IMREAD_GRAYSCALE);
ASSERT_TRUE(!img.empty()) << "can't open basketball1.png";
declare.in(img);
if (RUN_PLAIN_IMPL)
{
CascadeClassifier faceCascade;
ASSERT_TRUE(faceCascade.load(getDataPath("gpu/haarcascade/haarcascade_frontalface_alt.xml")))
<< "can't load haarcascade_frontalface_alt.xml";
vector<Rect> oclfaces;
ocl::OclCascadeClassifier faceCascade;
TEST_CYCLE() faceCascade.detectMultiScale(img, faces,
1.1, 2, 0 | CV_HAAR_SCALE_IMAGE, Size(30, 30));
if (!faceCascade.load(abspath("haarcascade_frontalface_alt.xml")))
{
throw runtime_error("can't load haarcascade_frontalface_alt.xml");
SANITY_CHECK(faces, 4 + 1e-4);
}
else if (RUN_OCL_IMPL)
{
ocl::OclCascadeClassifier faceCascade;
ocl::oclMat oclImg(img);
ocl::oclMat d_img(img);
ASSERT_TRUE(faceCascade.load(getDataPath("gpu/haarcascade/haarcascade_frontalface_alt.xml")))
<< "can't load haarcascade_frontalface_alt.xml";
WARMUP_ON;
faceCascade.detectMultiScale(d_img, oclfaces,
1.1, 2, 0 | CASCADE_SCALE_IMAGE, Size(30, 30));
WARMUP_OFF;
TEST_CYCLE() faceCascade.detectMultiScale(oclImg, faces,
1.1, 2, 0 | CV_HAAR_SCALE_IMAGE, Size(30, 30));
if(faces.size() == oclfaces.size())
TestSystem::instance().setAccurate(1, 0);
SANITY_CHECK(faces, 4 + 1e-4);
}
else
TestSystem::instance().setAccurate(0, abs((int)faces.size() - (int)oclfaces.size()));
faces.clear();
GPU_ON;
faceCascade.detectMultiScale(d_img, oclfaces,
1.1, 2, 0 | CASCADE_SCALE_IMAGE, Size(30, 30));
GPU_OFF;
GPU_FULL_ON;
d_img.upload(img);
faceCascade.detectMultiScale(d_img, oclfaces,
1.1, 2, 0 | CASCADE_SCALE_IMAGE, Size(30, 30));
GPU_FULL_OFF;
OCL_PERF_ELSE
}
modules/ocl/perf/perf_hog.cpp
View file @ 2d6f35d6
......@@ -45,50 +45,37 @@
//M*/
#include "perf_precomp.hpp"
using namespace perf;
///////////// HOG////////////////////////
PERFTEST(HOG)
PERF_TEST(HOGFixture, HOG)
{
Mat src = imread(abspath("road.png"), cv::IMREAD_GRAYSCALE);
if (src.empty())
{
throw runtime_error("can't open road.png");
}
cv::HOGDescriptor hog;
hog.setSVMDetector(hog.getDefaultPeopleDetector());
std::vector<cv::Rect> found_locations;
std::vector<cv::Rect> d_found_locations;
Mat src = imread(getDataPath("gpu/hog/road.png"), cv::IMREAD_GRAYSCALE);
ASSERT_TRUE(!src.empty()) << "can't open input image road.png";
SUBTEST << src.cols << 'x' << src.rows << "; road.png";
vector<cv::Rect> found_locations;
declare.in(src).time(5);
hog.detectMultiScale(src, found_locations);
if (RUN_PLAIN_IMPL)
{
HOGDescriptor hog;
hog.setSVMDetector(hog.getDefaultPeopleDetector());
CPU_ON;
hog.detectMultiScale(src, found_locations);
CPU_OFF;
TEST_CYCLE() hog.detectMultiScale(src, found_locations);
cv::ocl::HOGDescriptor ocl_hog;
ocl_hog.setSVMDetector(ocl_hog.getDefaultPeopleDetector());
ocl::oclMat d_src;
d_src.upload(src);
SANITY_CHECK(found_locations, 1 + DBL_EPSILON);
}
else if (RUN_OCL_IMPL)
{
ocl::HOGDescriptor ocl_hog;
ocl_hog.setSVMDetector(ocl_hog.getDefaultPeopleDetector());
ocl::oclMat oclSrc(src);
WARMUP_ON;
ocl_hog.detectMultiScale(d_src, d_found_locations);
WARMUP_OFF;
TEST_CYCLE() ocl_hog.detectMultiScale(oclSrc, found_locations);
if(d_found_locations.size() == found_locations.size())
TestSystem::instance().setAccurate(1, 0);
SANITY_CHECK(found_locations, 1 + DBL_EPSILON);
}
else
TestSystem::instance().setAccurate(0, abs((int)found_locations.size() - (int)d_found_locations.size()));
GPU_ON;
ocl_hog.detectMultiScale(d_src, found_locations);
GPU_OFF;
GPU_FULL_ON;
d_src.upload(src);
ocl_hog.detectMultiScale(d_src, found_locations);
GPU_FULL_OFF;
OCL_PERF_ELSE
}
modules/ocl/perf/perf_imgproc.cpp
View file @ 2d6f35d6
This diff is collapsed.
modules/ocl/perf/perf_match_template.cpp
View file @ 2d6f35d6
......@@ -45,101 +45,77 @@
//M*/
#include "perf_precomp.hpp"
/////////// matchTemplate ////////////////////////
//void InitMatchTemplate()
//{
// Mat src; gen(src, 500, 500, CV_32F, 0, 1);
// Mat templ; gen(templ, 500, 500, CV_32F, 0, 1);
// ocl::oclMat d_src(src), d_templ(templ), d_dst;
// ocl::matchTemplate(d_src, d_templ, d_dst, CV_TM_CCORR);
//}
PERFTEST(matchTemplate)
{
//InitMatchTemplate();
Mat src, templ, dst, ocl_dst;
int templ_size = 5;
for (int size = Min_Size; size <= Max_Size; size *= Multiple)
{
int all_type[] = {CV_32FC1, CV_32FC4};
std::string type_name[] = {"CV_32FC1", "CV_32FC4"};
for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++)
{
for(templ_size = 5; templ_size <= 5; templ_size *= 5)
{
gen(src, size, size, all_type[j], 0, 1);
SUBTEST << src.cols << 'x' << src.rows << "; " << type_name[j] << "; templ " << templ_size << 'x' << templ_size << "; CCORR";
using namespace perf;
using std::tr1::tuple;
using std::tr1::get;
gen(templ, templ_size, templ_size, all_type[j], 0, 1);
matchTemplate(src, templ, dst, TM_CCORR);
CPU_ON;
matchTemplate(src, templ, dst, TM_CCORR);
CPU_OFF;
ocl::oclMat d_src(src), d_templ(templ), d_dst;
WARMUP_ON;
ocl::matchTemplate(d_src, d_templ, d_dst, TM_CCORR);
WARMUP_OFF;
/////////// matchTemplate ////////////////////////
GPU_ON;
ocl::matchTemplate(d_src, d_templ, d_dst, TM_CCORR);
GPU_OFF;
typedef Size_MatType CV_TM_CCORRFixture;
GPU_FULL_ON;
d_src.upload(src);
d_templ.upload(templ);
ocl::matchTemplate(d_src, d_templ, d_dst, TM_CCORR);
d_dst.download(ocl_dst);
GPU_FULL_OFF;
PERF_TEST_P(CV_TM_CCORRFixture, matchTemplate,
::testing::Combine(::testing::Values(OCL_SIZE_1000, OCL_SIZE_2000),
OCL_PERF_ENUM(CV_32FC1, CV_32FC4)))
{
const Size_MatType_t params = GetParam();
const Size srcSize = get<0>(params), templSize(5, 5);
const int type = get<1>(params);
Mat src(srcSize, type), templ(templSize, type);
const Size dstSize(src.cols - templ.cols + 1, src.rows - templ.rows + 1);
Mat dst(dstSize, CV_32F);
randu(src, 0.0f, 1.0f);
randu(templ, 0.0f, 1.0f);
declare.time(srcSize == OCL_SIZE_2000 ? 20 : 6).in(src, templ).out(dst);
if (RUN_OCL_IMPL)
{
ocl::oclMat oclSrc(src), oclTempl(templ), oclDst(dstSize, CV_32F);
TestSystem::instance().ExpectedMatNear(dst, ocl_dst, templ.rows * templ.cols * 1e-1);
}
}
TEST_CYCLE() cv::ocl::matchTemplate(oclSrc, oclTempl, oclDst, TM_CCORR);
int all_type_8U[] = {CV_8UC1};
std::string type_name_8U[] = {"CV_8UC1"};
oclDst.download(dst);
for (size_t j = 0; j < sizeof(all_type_8U) / sizeof(int); j++)
{
for(templ_size = 5; templ_size <= 5; templ_size *= 5)
{
SUBTEST << src.cols << 'x' << src.rows << "; " << type_name_8U[j] << "; templ " << templ_size << 'x' << templ_size << "; CCORR_NORMED";
SANITY_CHECK(dst, 1e-4);
}
else if (RUN_PLAIN_IMPL)
{
TEST_CYCLE() cv::matchTemplate(src, templ, dst, TM_CCORR);
gen(src, size, size, all_type_8U[j], 0, 255);
SANITY_CHECK(dst, 1e-4);
}
else
OCL_PERF_ELSE
}
gen(templ, templ_size, templ_size, all_type_8U[j], 0, 255);
typedef TestBaseWithParam<Size> CV_TM_CCORR_NORMEDFixture;
matchTemplate(src, templ, dst, TM_CCORR_NORMED);
PERF_TEST_P(CV_TM_CCORR_NORMEDFixture, matchTemplate, OCL_TYPICAL_MAT_SIZES)
{
const Size srcSize = GetParam(), templSize(5, 5);
CPU_ON;
matchTemplate(src, templ, dst, TM_CCORR_NORMED);
CPU_OFF;
Mat src(srcSize, CV_8UC1), templ(templSize, CV_8UC1), dst;
const Size dstSize(src.cols - templ.cols + 1, src.rows - templ.rows + 1);
dst.create(dstSize, CV_8UC1);
declare.in(src, templ, WARMUP_RNG).out(dst)
.time(srcSize == OCL_SIZE_2000 ? 10 : srcSize == OCL_SIZE_4000 ? 23 : 2);
ocl::oclMat d_src(src);
ocl::oclMat d_templ(templ), d_dst;
if (RUN_OCL_IMPL)
{
ocl::oclMat oclSrc(src), oclTempl(templ), oclDst(dstSize, CV_8UC1);
WARMUP_ON;
ocl::matchTemplate(d_src, d_templ, d_dst, TM_CCORR_NORMED);
WARMUP_OFF;
TEST_CYCLE() cv::ocl::matchTemplate(oclSrc, oclTempl, oclDst, TM_CCORR_NORMED);
GPU_ON;
ocl::matchTemplate(d_src, d_templ, d_dst, TM_CCORR_NORMED);
GPU_OFF;
oclDst.download(dst);
GPU_FULL_ON;
d_src.upload(src);
d_templ.upload(templ);
ocl::matchTemplate(d_src, d_templ, d_dst, TM_CCORR_NORMED);
d_dst.download(ocl_dst);
GPU_FULL_OFF;
SANITY_CHECK(dst, 2e-2);
}
else if (RUN_PLAIN_IMPL)
{
TEST_CYCLE() cv::matchTemplate(src, templ, dst, TM_CCORR_NORMED);
TestSystem::instance().ExpectedMatNear(dst, ocl_dst, templ.rows * templ.cols * 1e-1);
}
}
SANITY_CHECK(dst, 2e-2);
}
else
OCL_PERF_ELSE
}
modules/ocl/perf/perf_matrix_operation.cpp
View file @ 2d6f35d6
......@@ -45,142 +45,113 @@
//M*/
#include "perf_precomp.hpp"
///////////// ConvertTo////////////////////////
PERFTEST(ConvertTo)
{
Mat src, dst, ocl_dst;
ocl::oclMat d_src, d_dst;
int all_type[] = {CV_8UC1, CV_8UC4};
std::string type_name[] = {"CV_8UC1", "CV_8UC4"};
for (int size = Min_Size; size <= Max_Size; size *= Multiple)
{
for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++)
{
SUBTEST << size << 'x' << size << "; " << type_name[j] << " to 32FC1";
using namespace perf;
using std::tr1::tuple;
using std::tr1::get;
gen(src, size, size, all_type[j], 0, 256);
//gen(dst, size, size, all_type[j], 0, 256);
//d_dst.upload(dst);
src.convertTo(dst, CV_32FC1);
///////////// ConvertTo////////////////////////
CPU_ON;
src.convertTo(dst, CV_32FC1);
CPU_OFF;
typedef Size_MatType ConvertToFixture;
d_src.upload(src);
PERF_TEST_P(ConvertToFixture, ConvertTo,
::testing::Combine(OCL_TYPICAL_MAT_SIZES,
OCL_PERF_ENUM(CV_8UC1, CV_8UC4)))
{
const Size_MatType_t params = GetParam();
const Size srcSize = get<0>(params);
const int type = get<1>(params);
WARMUP_ON;
d_src.convertTo(d_dst, CV_32FC1);
WARMUP_OFF;
Mat src(srcSize, type), dst;
const int dstType = CV_MAKE_TYPE(CV_32F, src.channels());
dst.create(srcSize, dstType);
declare.in(src, WARMUP_RNG).out(dst);
GPU_ON;
d_src.convertTo(d_dst, CV_32FC1);
GPU_OFF;
if (RUN_OCL_IMPL)
{
ocl::oclMat oclSrc(src), oclDst(srcSize, dstType);
GPU_FULL_ON;
d_src.upload(src);
d_src.convertTo(d_dst, CV_32FC1);
d_dst.download(ocl_dst);
GPU_FULL_OFF;
TEST_CYCLE() oclSrc.convertTo(oclDst, dstType);
TestSystem::instance().ExpectedMatNear(dst, ocl_dst, 0.0);
}
oclDst.download(dst);
SANITY_CHECK(dst);
}
}
///////////// copyTo////////////////////////
PERFTEST(copyTo)
{
Mat src, dst, ocl_dst;
ocl::oclMat d_src, d_dst;
int all_type[] = {CV_8UC1, CV_8UC4};
std::string type_name[] = {"CV_8UC1", "CV_8UC4"};
for (int size = Min_Size; size <= Max_Size; size *= Multiple)
else if (RUN_PLAIN_IMPL)
{
for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++)
{
SUBTEST << size << 'x' << size << "; " << type_name[j] ;
TEST_CYCLE() src.convertTo(dst, dstType);
gen(src, size, size, all_type[j], 0, 256);
//gen(dst, size, size, all_type[j], 0, 256);
//d_dst.upload(dst);
SANITY_CHECK(dst);
}
else
OCL_PERF_ELSE
}
src.copyTo(dst);
///////////// copyTo////////////////////////
CPU_ON;
src.copyTo(dst);
CPU_OFF;
typedef Size_MatType copyToFixture;
d_src.upload(src);
PERF_TEST_P(copyToFixture, copyTo,
::testing::Combine(OCL_TYPICAL_MAT_SIZES,
OCL_PERF_ENUM(CV_8UC1, CV_8UC4)))
{
const Size_MatType_t params = GetParam();
const Size srcSize = get<0>(params);
const int type = get<1>(params);
WARMUP_ON;
d_src.copyTo(d_dst);
WARMUP_OFF;
Mat src(srcSize, type), dst(srcSize, type);
declare.in(src, WARMUP_RNG).out(dst);
GPU_ON;
d_src.copyTo(d_dst);
GPU_OFF;
if (RUN_OCL_IMPL)
{
ocl::oclMat oclSrc(src), oclDst(srcSize, type);
GPU_FULL_ON;
d_src.upload(src);
d_src.copyTo(d_dst);
d_dst.download(ocl_dst);
GPU_FULL_OFF;
TEST_CYCLE() oclSrc.copyTo(oclDst);
TestSystem::instance().ExpectedMatNear(dst, ocl_dst, 0.0);
}
oclDst.download(dst);
SANITY_CHECK(dst);
}
}
///////////// setTo////////////////////////
PERFTEST(setTo)
{
Mat src, ocl_src;
Scalar val(1, 2, 3, 4);
ocl::oclMat d_src;
int all_type[] = {CV_8UC1, CV_8UC4};
std::string type_name[] = {"CV_8UC1", "CV_8UC4"};
for (int size = Min_Size; size <= Max_Size; size *= Multiple)
else if (RUN_PLAIN_IMPL)
{
for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++)
{
SUBTEST << size << 'x' << size << "; " << type_name[j] ;
TEST_CYCLE() src.copyTo(dst);
gen(src, size, size, all_type[j], 0, 256);
SANITY_CHECK(dst);
}
else
OCL_PERF_ELSE
}
src.setTo(val);
///////////// setTo////////////////////////
CPU_ON;
src.setTo(val);
CPU_OFF;
typedef Size_MatType setToFixture;
d_src.upload(src);
PERF_TEST_P(setToFixture, setTo,
::testing::Combine(OCL_TYPICAL_MAT_SIZES,
OCL_PERF_ENUM(CV_8UC1, CV_8UC4)))
{
const Size_MatType_t params = GetParam();
const Size srcSize = get<0>(params);
const int type = get<1>(params);
const Scalar val(1, 2, 3, 4);
WARMUP_ON;
d_src.setTo(val);
WARMUP_OFF;
Mat src(srcSize, type);
declare.in(src);
d_src.download(ocl_src);
TestSystem::instance().ExpectedMatNear(src, ocl_src, 1.0);
if (RUN_OCL_IMPL)
{
ocl::oclMat oclSrc(srcSize, type);
GPU_ON;;
d_src.setTo(val);
GPU_OFF;
TEST_CYCLE() oclSrc.setTo(val);
oclSrc.download(src);
GPU_FULL_ON;
d_src.upload(src);
d_src.setTo(val);
GPU_FULL_OFF;
}
SANITY_CHECK(src);
}
else if (RUN_PLAIN_IMPL)
{
TEST_CYCLE() src.setTo(val);
SANITY_CHECK(src);
}
else
OCL_PERF_ELSE
}
modules/ocl/perf/perf_moments.cpp
View file @ 2d6f35d6
......@@ -43,50 +43,47 @@
// the use of this software, even if advised of the possibility of such damage.
//
//M*/
#include "perf_precomp.hpp"
///////////// Moments ////////////////////////
PERFTEST(Moments)
{
Mat src;
bool binaryImage = 0;
int all_type[] = {CV_8UC1, CV_16SC1, CV_32FC1, CV_64FC1};
std::string type_name[] = {"CV_8UC1", "CV_16SC1", "CV_32FC1", "CV_64FC1"};
for (int size = Min_Size; size <= Max_Size; size *= Multiple)
{
for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++)
{
SUBTEST << size << 'x' << size << "; " << type_name[j];
#include "perf_precomp.hpp"
gen(src, size, size, all_type[j], 0, 256);
using namespace perf;
using std::tr1::tuple;
using std::tr1::get;
cv::Moments CvMom = moments(src, binaryImage);
///////////// Moments ////////////////////////
CPU_ON;
moments(src, binaryImage);
CPU_OFF;
typedef Size_MatType MomentsFixture;
cv::Moments oclMom;
WARMUP_ON;
oclMom = ocl::ocl_moments(src, binaryImage);
WARMUP_OFF;
PERF_TEST_P(MomentsFixture, DISABLED_Moments,
::testing::Combine(OCL_TYPICAL_MAT_SIZES,
OCL_PERF_ENUM(CV_8UC1, CV_16SC1, CV_32FC1, CV_64FC1))) // TODO does not work properly (see below)
{
const Size_MatType_t params = GetParam();
const Size srcSize = get<0>(params);
const int type = get<1>(params);
Mat gpu_dst, cpu_dst;
HuMoments(CvMom, cpu_dst);
HuMoments(oclMom, gpu_dst);
Mat src(srcSize, type), dst(7, 1, CV_64F);
const bool binaryImage = false;
cv::Moments mom;
GPU_ON;
ocl::ocl_moments(src, binaryImage);
GPU_OFF;
declare.in(src, WARMUP_RNG).out(dst);
GPU_FULL_ON;
ocl::ocl_moments(src, binaryImage);
GPU_FULL_OFF;
if (RUN_OCL_IMPL)
{
ocl::oclMat oclSrc(src);
TestSystem::instance().ExpectedMatNear(gpu_dst, cpu_dst, .5);
TEST_CYCLE() mom = cv::ocl::ocl_moments(oclSrc, binaryImage); // TODO Use oclSrc
cv::HuMoments(mom, dst);
}
SANITY_CHECK(dst);
}
else if (RUN_PLAIN_IMPL)
{
TEST_CYCLE() mom = cv::moments(src, binaryImage);
cv::HuMoments(mom, dst);
SANITY_CHECK(dst);
}
else
OCL_PERF_ELSE
}
modules/ocl/perf/perf_norm.cpp
View file @ 2d6f35d6
......@@ -45,43 +45,39 @@
//M*/
#include "perf_precomp.hpp"
///////////// norm////////////////////////
PERFTEST(norm)
{
Mat src1, src2, ocl_src1;
ocl::oclMat d_src1, d_src2;
using namespace perf;
using std::tr1::tuple;
using std::tr1::get;
for (int size = Min_Size; size <= Max_Size; size *= Multiple)
{
SUBTEST << size << 'x' << size << "; CV_8UC1; NORM_INF";
gen(src1, size, size, CV_8UC1, Scalar::all(0), Scalar::all(1));
gen(src2, size, size, CV_8UC1, Scalar::all(0), Scalar::all(1));
///////////// norm////////////////////////
norm(src1, src2, NORM_INF);
typedef TestBaseWithParam<Size> normFixture;
CPU_ON;
norm(src1, src2, NORM_INF);
CPU_OFF;
PERF_TEST_P(normFixture, DISABLED_norm, OCL_TYPICAL_MAT_SIZES) // TODO doesn't work properly
{
const Size srcSize = GetParam();
const std::string impl = getSelectedImpl();
double value = 0.0;
d_src1.upload(src1);
d_src2.upload(src2);
Mat src1(srcSize, CV_8UC1), src2(srcSize, CV_8UC1);
declare.in(src1, src2);
randu(src1, 0, 1);
randu(src2, 0, 1);
WARMUP_ON;
ocl::norm(d_src1, d_src2, NORM_INF);
WARMUP_OFF;
if (RUN_OCL_IMPL)
{
ocl::oclMat oclSrc1(src1), oclSrc2(src2);
d_src1.download(ocl_src1);
TestSystem::instance().ExpectedMatNear(src1, ocl_src1, .5);
TEST_CYCLE() value = cv::ocl::norm(oclSrc1, oclSrc2, NORM_INF);
GPU_ON;
ocl::norm(d_src1, d_src2, NORM_INF);
GPU_OFF;
SANITY_CHECK(value);
}
else if (RUN_PLAIN_IMPL)
{
TEST_CYCLE() value = cv::norm(src1, src2, NORM_INF);
GPU_FULL_ON;
d_src1.upload(src1);
d_src2.upload(src2);
ocl::norm(d_src1, d_src2, NORM_INF);
GPU_FULL_OFF;
SANITY_CHECK(value);
}
else
OCL_PERF_ELSE
}
modules/ocl/perf/perf_opticalflow.cpp
View file @ 2d6f35d6
This diff is collapsed.
modules/ocl/perf/perf_precomp.cpp
View file @ 2d6f35d6
This diff is collapsed.
modules/ocl/perf/perf_precomp.hpp
View file @ 2d6f35d6
This diff is collapsed.
modules/ocl/perf/perf_pyramid.cpp
View file @ 2d6f35d6
This diff is collapsed.
modules/ocl/perf/perf_split_merge.cpp
View file @ 2d6f35d6
This diff is collapsed.
modules/ocl/src/arithm.cpp
View file @ 2d6f35d6
......@@ -2337,7 +2337,7 @@ void cv::ocl::pow(const oclMat &x, double p, oclMat &y)
return;
}
CV_Assert((x.type() == y.type() && x.size() == y.size() && x.depth() == CV_32F) || x.depth() == CV_64F);
CV_Assert(x.depth() == CV_32F || x.depth() == CV_64F);
y.create(x.size(), x.type());
String kernelName = "arithm_pow";
......
modules/ocl/test/test_norm.cpp 0 → 100644
View file @ 2d6f35d6
This diff is collapsed.
platforms/ios/Info.plist.in
View file @ 2d6f35d6
......@@ -7,9 +7,9 @@
<key>CFBundleIdentifier</key>
<string>org.opencv</string>
<key>CFBundleVersion</key>
<string>${VERSION}</string>
<string>${OPENCV_LIBVERSION}</string>
<key>CFBundleShortVersionString</key>
<string>${VERSION}</string>
<string>${OPENCV_LIBVERSION}</string>
<key>CFBundleSignature</key>
<string>????</string>
<key>CFBundlePackageType</key>
......
platforms/ios/build_framework.py
View file @ 2d6f35d6
This diff is collapsed.
samples/gpu/super_resolution.cpp
View file @ 2d6f35d6
......@@ -212,7 +212,7 @@ int main(int argc, const char* argv[])
#if defined(HAVE_OPENCV_OCL)
cout << "Mode : " << (useCuda ? "CUDA" : useOcl? "OpenCL" : "CPU") << endl;
#else
cout << "Mode : " << (useGpu ? "CUDA" : "CPU") << endl;
cout << "Mode : " << (useCuda ? "CUDA" : "CPU") << endl;
#endif
}
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment