From 5087ff08146ce957f6b8f9df56669ede451f98f2 Mon Sep 17 00:00:00 2001 From: Dmitry Budnikov Date: Thu, 8 Nov 2018 22:14:53 +0300 Subject: [PATCH] Merge pull request #13008 from dbudniko:dbudniko/gpu_opencl_backend G-API GPU-OpenCL backend (#13008) * gpu/ocl backend core * accuracy tests added and adjusted + license headers * GPU perf. tests added; almost all adjusted to pass * all tests adjusted and passed - ready for pull request * missing license headers * fix warning (workaround RGB2Gray) * fix c++ magic * precompiled header * white spaces * try to fix warning and blur test * try to fix Blur perf tests * more alignments with the latest cpu backend * more gapi tests refactoring + 1 more UB issue fix + more informative tolerance exceed reports * white space fix * try workaround for SumTest * GAPI_EXPORTS instead CV_EXPORTS --- modules/gapi/CMakeLists.txt | 8 + modules/gapi/include/opencv2/gapi/garg.hpp | 2 + modules/gapi/include/opencv2/gapi/gmat.hpp | 1 + .../gapi/include/opencv2/gapi/gpu/core.hpp | 27 + .../include/opencv2/gapi/gpu/ggpukernel.hpp | 230 +++++++ .../gapi/include/opencv2/gapi/gpu/imgproc.hpp | 27 + .../gapi/perf/common/gapi_core_perf_tests.hpp | 18 +- .../perf/common/gapi_core_perf_tests_inl.hpp | 131 ++-- .../perf/cpu/gapi_core_perf_tests_cpu.cpp | 435 ++++++------- .../perf/cpu/gapi_imgproc_perf_tests_cpu.cpp | 296 +++++---- .../perf/gpu/gapi_core_perf_tests_gpu.cpp | 291 +++++++++ .../perf/gpu/gapi_imgproc_perf_tests_gpu.cpp | 180 ++++++ modules/gapi/perf/perf_precomp.hpp | 1 + modules/gapi/src/api/gbackend.cpp | 86 ++- modules/gapi/src/api/gmat.cpp | 4 + modules/gapi/src/api/gproto.cpp | 1 + modules/gapi/src/backends/common/gbackend.hpp | 13 +- modules/gapi/src/backends/gpu/ggpubackend.cpp | 226 +++++++ modules/gapi/src/backends/gpu/ggpubackend.hpp | 72 +++ modules/gapi/src/backends/gpu/ggpucore.cpp | 582 ++++++++++++++++++ modules/gapi/src/backends/gpu/ggpucore.hpp | 24 + modules/gapi/src/backends/gpu/ggpuimgproc.cpp | 277 +++++++++ modules/gapi/src/backends/gpu/ggpuimgproc.hpp | 23 + modules/gapi/src/backends/gpu/ggpukernel.cpp | 50 ++ modules/gapi/test/common/gapi_core_tests.hpp | 10 +- .../gapi/test/common/gapi_core_tests_inl.hpp | 43 +- .../gapi/test/common/gapi_operators_tests.hpp | 4 +- .../test/common/gapi_operators_tests_inl.hpp | 10 +- .../gapi/test/common/gapi_tests_common.hpp | 251 ++++++++ modules/gapi/test/cpu/gapi_core_tests_cpu.cpp | 12 +- .../gapi/test/cpu/gapi_core_tests_fluid.cpp | 14 +- .../gapi/test/cpu/gapi_imgproc_tests_cpu.cpp | 22 +- .../test/cpu/gapi_imgproc_tests_fluid.cpp | 151 +---- .../test/cpu/gapi_operators_tests_cpu.cpp | 90 +-- .../test/cpu/gapi_operators_tests_fluid.cpp | 99 +-- modules/gapi/test/gpu/gapi_core_tests_gpu.cpp | 395 ++++++++++++ .../gapi/test/gpu/gapi_imgproc_tests_gpu.cpp | 227 +++++++ .../test/gpu/gapi_operators_tests_gpu.cpp | 72 +++ modules/gapi/test/test_precomp.hpp | 1 + 39 files changed, 3677 insertions(+), 729 deletions(-) create mode 100644 modules/gapi/include/opencv2/gapi/gpu/core.hpp create mode 100644 modules/gapi/include/opencv2/gapi/gpu/ggpukernel.hpp create mode 100644 modules/gapi/include/opencv2/gapi/gpu/imgproc.hpp create mode 100644 modules/gapi/perf/gpu/gapi_core_perf_tests_gpu.cpp create mode 100644 modules/gapi/perf/gpu/gapi_imgproc_perf_tests_gpu.cpp create mode 100644 modules/gapi/src/backends/gpu/ggpubackend.cpp create mode 100644 modules/gapi/src/backends/gpu/ggpubackend.hpp create mode 100644 modules/gapi/src/backends/gpu/ggpucore.cpp create mode 100644 modules/gapi/src/backends/gpu/ggpucore.hpp create mode 100644 modules/gapi/src/backends/gpu/ggpuimgproc.cpp create mode 100644 modules/gapi/src/backends/gpu/ggpuimgproc.hpp create mode 100644 modules/gapi/src/backends/gpu/ggpukernel.cpp create mode 100644 modules/gapi/test/gpu/gapi_core_tests_gpu.cpp create mode 100644 modules/gapi/test/gpu/gapi_imgproc_tests_gpu.cpp create mode 100644 modules/gapi/test/gpu/gapi_operators_tests_gpu.cpp diff --git a/modules/gapi/CMakeLists.txt b/modules/gapi/CMakeLists.txt index 809d7303b4..d854a49635 100644 --- a/modules/gapi/CMakeLists.txt +++ b/modules/gapi/CMakeLists.txt @@ -22,6 +22,7 @@ file(GLOB gapi_ext_hdrs "${CMAKE_CURRENT_LIST_DIR}/include/opencv2/${name}/*.h" "${CMAKE_CURRENT_LIST_DIR}/include/opencv2/${name}/util/*.hpp" "${CMAKE_CURRENT_LIST_DIR}/include/opencv2/${name}/cpu/*.hpp" + "${CMAKE_CURRENT_LIST_DIR}/include/opencv2/${name}/gpu/*.hpp" "${CMAKE_CURRENT_LIST_DIR}/include/opencv2/${name}/fluid/*.hpp" "${CMAKE_CURRENT_LIST_DIR}/include/opencv2/${name}/own/*.hpp" ) @@ -70,6 +71,13 @@ set(gapi_srcs src/backends/fluid/gfluidimgproc.cpp src/backends/fluid/gfluidcore.cpp + # GPU Backend (currently built-in) + src/backends/gpu/ggpubackend.cpp + src/backends/gpu/ggpukernel.cpp + src/backends/gpu/ggpuimgproc.cpp + src/backends/gpu/ggpucore.cpp + + # Compound src/backends/common/gcompoundbackend.cpp src/backends/common/gcompoundkernel.cpp diff --git a/modules/gapi/include/opencv2/gapi/garg.hpp b/modules/gapi/include/opencv2/gapi/garg.hpp index 4a9e27d193..f8a3170068 100644 --- a/modules/gapi/include/opencv2/gapi/garg.hpp +++ b/modules/gapi/include/opencv2/gapi/garg.hpp @@ -90,6 +90,7 @@ using GRunArg = util::variant< #if !defined(GAPI_STANDALONE) cv::Mat, cv::Scalar, + cv::UMat, #endif // !defined(GAPI_STANDALONE) cv::gapi::own::Mat, cv::gapi::own::Scalar, @@ -101,6 +102,7 @@ using GRunArgP = util::variant< #if !defined(GAPI_STANDALONE) cv::Mat*, cv::Scalar*, + cv::UMat*, #endif // !defined(GAPI_STANDALONE) cv::gapi::own::Mat*, cv::gapi::own::Scalar*, diff --git a/modules/gapi/include/opencv2/gapi/gmat.hpp b/modules/gapi/include/opencv2/gapi/gmat.hpp index 106f09f22c..c8b3eb799c 100644 --- a/modules/gapi/include/opencv2/gapi/gmat.hpp +++ b/modules/gapi/include/opencv2/gapi/gmat.hpp @@ -119,6 +119,7 @@ static inline GMatDesc empty_gmat_desc() { return GMatDesc{-1,-1,{-1,-1}}; } #if !defined(GAPI_STANDALONE) class Mat; GAPI_EXPORTS GMatDesc descr_of(const cv::Mat &mat); +GAPI_EXPORTS GMatDesc descr_of(const cv::UMat &mat); #endif // !defined(GAPI_STANDALONE) namespace gapi { namespace own { diff --git a/modules/gapi/include/opencv2/gapi/gpu/core.hpp b/modules/gapi/include/opencv2/gapi/gpu/core.hpp new file mode 100644 index 0000000000..98d49b5b8b --- /dev/null +++ b/modules/gapi/include/opencv2/gapi/gpu/core.hpp @@ -0,0 +1,27 @@ +// This file is part of OpenCV project. +// It is subject to the license terms in the LICENSE file found in the top-level directory +// of this distribution and at http://opencv.org/license.html. +// +// Copyright (C) 2018 Intel Corporation + + +#ifndef OPENCV_GAPI_GPU_CORE_API_HPP +#define OPENCV_GAPI_GPU_CORE_API_HPP + +#include // GAPI_EXPORTS +#include // GKernelPackage + +namespace cv { +namespace gapi { +namespace core { +namespace gpu { + +GAPI_EXPORTS GKernelPackage kernels(); + +} // namespace gpu +} // namespace core +} // namespace gapi +} // namespace cv + + +#endif // OPENCV_GAPI_GPU_CORE_API_HPP diff --git a/modules/gapi/include/opencv2/gapi/gpu/ggpukernel.hpp b/modules/gapi/include/opencv2/gapi/gpu/ggpukernel.hpp new file mode 100644 index 0000000000..1321b51168 --- /dev/null +++ b/modules/gapi/include/opencv2/gapi/gpu/ggpukernel.hpp @@ -0,0 +1,230 @@ +// This file is part of OpenCV project. +// It is subject to the license terms in the LICENSE file found in the top-level directory +// of this distribution and at http://opencv.org/license.html. +// +// Copyright (C) 2018 Intel Corporation + + +#ifndef OPENCV_GAPI_GGPUKERNEL_HPP +#define OPENCV_GAPI_GGPUKERNEL_HPP + +#include +#include +#include +#include + +#include +#include +#include +#include + +// FIXME: namespace scheme for backends? +namespace cv { + +namespace gimpl +{ + // Forward-declare an internal class + class GGPUExecutable; +} // namespace gimpl + +namespace gapi +{ +namespace gpu +{ + GAPI_EXPORTS cv::gapi::GBackend backend(); +} // namespace gpu +} // namespace gapi + +// Represents arguments which are passed to a wrapped GPU function +// FIXME: put into detail? +class GAPI_EXPORTS GGPUContext +{ +public: + // Generic accessor API + template + const T& inArg(int input) { return m_args.at(input).get(); } + + // Syntax sugar + const cv::UMat& inMat(int input); + cv::UMat& outMatR(int output); // FIXME: Avoid cv::Mat m = ctx.outMatR() + + const cv::gapi::own::Scalar& inVal(int input); + cv::gapi::own::Scalar& outValR(int output); // FIXME: Avoid cv::gapi::own::Scalar s = ctx.outValR() + template std::vector& outVecR(int output) // FIXME: the same issue + { + return outVecRef(output).wref(); + } + +protected: + detail::VectorRef& outVecRef(int output); + + std::vector m_args; + std::unordered_map m_results; + + + friend class gimpl::GGPUExecutable; +}; + +class GAPI_EXPORTS GGPUKernel +{ +public: + // This function is kernel's execution entry point (does the processing work) + using F = std::function; + + GGPUKernel(); + explicit GGPUKernel(const F& f); + + void apply(GGPUContext &ctx); + +protected: + F m_f; +}; + +// FIXME: This is an ugly ad-hoc imlpementation. TODO: refactor + +namespace detail +{ +template struct gpu_get_in; +template<> struct gpu_get_in +{ + static cv::UMat get(GGPUContext &ctx, int idx) { return ctx.inMat(idx); } +}; +template<> struct gpu_get_in +{ + static cv::Scalar get(GGPUContext &ctx, int idx) { return to_ocv(ctx.inVal(idx)); } +}; +template struct gpu_get_in > +{ + static const std::vector& get(GGPUContext &ctx, int idx) { return ctx.inArg(idx).rref(); } +}; +template struct gpu_get_in +{ + static T get(GGPUContext &ctx, int idx) { return ctx.inArg(idx); } +}; + +struct tracked_cv_umat{ + //TODO Think if T - API could reallocate UMat to a proper size - how do we handle this ? + //tracked_cv_umat(cv::UMat& m) : r{(m)}, original_data{m.getMat(ACCESS_RW).data} {} + tracked_cv_umat(cv::UMat& m) : r{ (m) }, original_data{ nullptr } {} + cv::UMat r; + uchar* original_data; + + operator cv::UMat& (){ return r;} + void validate() const{ + //if (r.getMat(ACCESS_RW).data != original_data) + //{ + // util::throw_error + // (std::logic_error + // ("OpenCV kernel output parameter was reallocated. \n" + // "Incorrect meta data was provided ?")); + //} + + } +}; + +struct scalar_wrapper_gpu +{ + //FIXME reuse CPU (OpenCV) plugin code + scalar_wrapper_gpu(cv::gapi::own::Scalar& s) : m_s{cv::gapi::own::to_ocv(s)}, m_org_s{s} {}; + operator cv::Scalar& () { return m_s; } + void writeBack() const { m_org_s = to_own(m_s); } + + cv::Scalar m_s; + cv::gapi::own::Scalar& m_org_s; +}; + +template +void postprocess_gpu(Outputs&... outs) +{ + struct + { + void operator()(tracked_cv_umat* bm) { bm->validate(); } + void operator()(scalar_wrapper_gpu* sw) { sw->writeBack(); } + void operator()(...) { } + + } validate; + //dummy array to unfold parameter pack + int dummy[] = { 0, (validate(&outs), 0)... }; + cv::util::suppress_unused_warning(dummy); +} + +template struct gpu_get_out; +template<> struct gpu_get_out +{ + static tracked_cv_umat get(GGPUContext &ctx, int idx) + { + auto& r = ctx.outMatR(idx); + return{ r }; + } +}; +template<> struct gpu_get_out +{ + static scalar_wrapper_gpu get(GGPUContext &ctx, int idx) + { + auto& s = ctx.outValR(idx); + return{ s }; + } +}; +template struct gpu_get_out > +{ + static std::vector& get(GGPUContext &ctx, int idx) { return ctx.outVecR(idx); } +}; + +template +struct GPUCallHelper; + +// FIXME: probably can be simplified with std::apply or analogue. +template +struct GPUCallHelper, std::tuple > +{ + template + struct call_and_postprocess + { + template + static void call(Inputs&&... ins, Outputs&&... outs) + { + //not using a std::forward on outs is deliberate in order to + //cause compilation error, by tring to bind rvalue references to lvalue references + Impl::run(std::forward(ins)..., outs...); + + postprocess_gpu(outs...); + } + }; + + template + static void call_impl(GGPUContext &ctx, detail::Seq, detail::Seq) + { + //TODO: Make sure that OpenCV kernels do not reallocate memory for output parameters + //by comparing it's state (data ptr) before and after the call. + //Convert own::Scalar to cv::Scalar before call kernel and run kernel + //convert cv::Scalar to own::Scalar after call kernel and write back results + call_and_postprocess::get(ctx, IIs))...>::call(gpu_get_in::get(ctx, IIs)..., gpu_get_out::get(ctx, OIs)...); + } + + static void call(GGPUContext &ctx) + { + call_impl(ctx, + typename detail::MkSeq::type(), + typename detail::MkSeq::type()); + } +}; + +} // namespace detail + +template +class GGPUKernelImpl: public detail::GPUCallHelper +{ + using P = detail::GPUCallHelper; + +public: + using API = K; + + static cv::gapi::GBackend backend() { return cv::gapi::gpu::backend(); } + static cv::GGPUKernel kernel() { return GGPUKernel(&P::call); } +}; + +#define GAPI_GPU_KERNEL(Name, API) struct Name: public cv::GGPUKernelImpl + +} // namespace cv + +#endif // OPENCV_GAPI_GGPUKERNEL_HPP diff --git a/modules/gapi/include/opencv2/gapi/gpu/imgproc.hpp b/modules/gapi/include/opencv2/gapi/gpu/imgproc.hpp new file mode 100644 index 0000000000..6071dda98b --- /dev/null +++ b/modules/gapi/include/opencv2/gapi/gpu/imgproc.hpp @@ -0,0 +1,27 @@ +// This file is part of OpenCV project. +// It is subject to the license terms in the LICENSE file found in the top-level directory +// of this distribution and at http://opencv.org/license.html. +// +// Copyright (C) 2018 Intel Corporation + + +#ifndef OPENCV_GAPI_GPU_IMGPROC_API_HPP +#define OPENCV_GAPI_GPU_IMGPROC_API_HPP + +#include // GAPI_EXPORTS +#include // GKernelPackage + +namespace cv { +namespace gapi { +namespace imgproc { +namespace gpu { + +GAPI_EXPORTS GKernelPackage kernels(); + +} // namespace gpu +} // namespace imgproc +} // namespace gapi +} // namespace cv + + +#endif // OPENCV_GAPI_GPU_IMGPROC_API_HPP diff --git a/modules/gapi/perf/common/gapi_core_perf_tests.hpp b/modules/gapi/perf/common/gapi_core_perf_tests.hpp index 791ee87a40..8af7b1abfb 100644 --- a/modules/gapi/perf/common/gapi_core_perf_tests.hpp +++ b/modules/gapi/perf/common/gapi_core_perf_tests.hpp @@ -34,13 +34,13 @@ namespace opencv_test class MulPerfTest : public TestPerfParams> {}; class MulDoublePerfTest : public TestPerfParams> {}; class MulCPerfTest : public TestPerfParams> {}; - class DivPerfTest : public TestPerfParams> {}; + class DivPerfTest : public TestPerfParams> {}; class DivCPerfTest : public TestPerfParams> {}; - class DivRCPerfTest : public TestPerfParams> {}; + class DivRCPerfTest : public TestPerfParams> {}; class MaskPerfTest : public TestPerfParams> {}; class MeanPerfTest : public TestPerfParams> {}; - class Polar2CartPerfTest : public TestPerfParams> {}; - class Cart2PolarPerfTest : public TestPerfParams> {}; + class Polar2CartPerfTest : public TestPerfParams> {}; + class Cart2PolarPerfTest : public TestPerfParams> {}; class CmpPerfTest : public TestPerfParams> {}; class CmpWithScalarPerfTest : public TestPerfParams> {}; class BitwisePerfTest : public TestPerfParams> {}; @@ -50,9 +50,9 @@ namespace opencv_test class MaxPerfTest : public TestPerfParams> {}; class AbsDiffPerfTest : public TestPerfParams> {}; class AbsDiffCPerfTest : public TestPerfParams> {}; - class SumPerfTest : public TestPerfParams> {}; - class AddWeightedPerfTest : public TestPerfParams> {}; - class NormPerfTest : public TestPerfParams> {}; + class SumPerfTest : public TestPerfParams> {}; + class AddWeightedPerfTest : public TestPerfParams> {}; + class NormPerfTest : public TestPerfParams> {}; class IntegralPerfTest : public TestPerfParams> {}; class ThresholdPerfTest : public TestPerfParams> {}; class ThresholdOTPerfTest : public TestPerfParams> {}; @@ -70,7 +70,7 @@ namespace opencv_test class ConcatVertVecPerfTest : public TestPerfParams> {}; class LUTPerfTest : public TestPerfParams> {}; class ConvertToPerfTest : public TestPerfParams> {}; - class ResizePerfTest : public TestPerfParams> {}; - class ResizeFxFyPerfTest : public TestPerfParams> {}; + class ResizePerfTest : public TestPerfParams> {}; + class ResizeFxFyPerfTest : public TestPerfParams> {}; } #endif // OPENCV_GAPI_CORE_PERF_TESTS_HPP diff --git a/modules/gapi/perf/common/gapi_core_perf_tests_inl.hpp b/modules/gapi/perf/common/gapi_core_perf_tests_inl.hpp index ccf55eee53..64ace29c5f 100644 --- a/modules/gapi/perf/common/gapi_core_perf_tests_inl.hpp +++ b/modules/gapi/perf/common/gapi_core_perf_tests_inl.hpp @@ -298,10 +298,11 @@ PERF_TEST_P_(MulCPerfTest, TestPerformance) PERF_TEST_P_(DivPerfTest, TestPerformance) { - Size sz = get<0>(GetParam()); - MatType type = get<1>(GetParam()); - int dtype = get<2>(GetParam()); - cv::GCompileArgs compile_args = get<3>(GetParam()); + compare_f cmpF = get<0>(GetParam()); + Size sz = get<1>(GetParam()); + MatType type = get<2>(GetParam()); + int dtype = get<3>(GetParam()); + cv::GCompileArgs compile_args = get<4>(GetParam()); initMatsRandU(type, sz, dtype, false); @@ -322,7 +323,7 @@ PERF_TEST_P_(DivPerfTest, TestPerformance) } // Comparison //////////////////////////////////////////////////////////// - EXPECT_EQ(0, cv::countNonZero(out_mat_gapi != out_mat_ocv)); + EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv)); EXPECT_EQ(out_mat_gapi.size(), sz); SANITY_CHECK_NOTHING(); @@ -367,10 +368,11 @@ PERF_TEST_P_(DivCPerfTest, TestPerformance) PERF_TEST_P_(DivRCPerfTest, TestPerformance) { - Size sz = get<0>(GetParam()); - MatType type = get<1>(GetParam()); - int dtype = get<2>(GetParam()); - cv::GCompileArgs compile_args = get<3>(GetParam()); + compare_f cmpF = get<0>(GetParam()); + Size sz = get<1>(GetParam()); + MatType type = get<2>(GetParam()); + int dtype = get<3>(GetParam()); + cv::GCompileArgs compile_args = get<4>(GetParam()); initMatsRandU(type, sz, dtype, false); @@ -392,7 +394,7 @@ PERF_TEST_P_(DivRCPerfTest, TestPerformance) } // Comparison //////////////////////////////////////////////////////////// - EXPECT_EQ(0, cv::countNonZero(out_mat_gapi != out_mat_ocv)); + EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv)); EXPECT_EQ(out_mat_gapi.size(), sz); SANITY_CHECK_NOTHING(); @@ -472,8 +474,9 @@ PERF_TEST_P_(MeanPerfTest, TestPerformance) PERF_TEST_P_(Polar2CartPerfTest, TestPerformance) { - Size sz_in = get<0>(GetParam()); - cv::GCompileArgs compile_args = get<1>(GetParam()); + compare_f cmpF = get<0>(GetParam()); + Size sz_in = get<1>(GetParam()); + cv::GCompileArgs compile_args = get<2>(GetParam()); initMatsRandU(CV_32FC1, sz_in, CV_32FC1, false); cv::Mat out_mat2; @@ -494,10 +497,9 @@ PERF_TEST_P_(Polar2CartPerfTest, TestPerformance) { c.apply(gin(in_mat1, in_mat2), gout(out_mat_gapi, out_mat2), std::move(compile_args)); } - // Comparison //////////////////////////////////////////////////////////// - EXPECT_EQ(0, cv::countNonZero(out_mat_gapi != out_mat_ocv)); - EXPECT_EQ(0, cv::countNonZero(out_mat_ocv2 != out_mat2)); + EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv)); + EXPECT_TRUE(cmpF(out_mat_ocv2, out_mat2)); EXPECT_EQ(out_mat_gapi.size(), sz_in); SANITY_CHECK_NOTHING(); @@ -507,8 +509,9 @@ PERF_TEST_P_(Polar2CartPerfTest, TestPerformance) PERF_TEST_P_(Cart2PolarPerfTest, TestPerformance) { - Size sz_in = get<0>(GetParam()); - cv::GCompileArgs compile_args = get<1>(GetParam()); + compare_f cmpF = get<0>(GetParam()); + Size sz_in = get<1>(GetParam()); + cv::GCompileArgs compile_args = get<2>(GetParam()); initMatsRandU(CV_32FC1, sz_in, CV_32FC1, false); cv::Mat out_mat2(sz_in, CV_32FC1); @@ -531,8 +534,8 @@ PERF_TEST_P_(Cart2PolarPerfTest, TestPerformance) } // Comparison //////////////////////////////////////////////////////////// - EXPECT_EQ(0, cv::countNonZero(out_mat_gapi != out_mat_ocv)); - EXPECT_EQ(0, cv::countNonZero(out_mat_ocv2 != out_mat2)); + EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv)); + EXPECT_TRUE(cmpF(out_mat_ocv2, out_mat2)); EXPECT_EQ(out_mat_gapi.size(), sz_in); SANITY_CHECK_NOTHING(); @@ -892,7 +895,8 @@ PERF_TEST_P_(SumPerfTest, TestPerformance) { cv::Size sz_in = get<0>(GetParam()); MatType type = get<1>(GetParam()); - cv::GCompileArgs compile_args = get<2>(GetParam()); + double tolerance = get<2>(GetParam()); + cv::GCompileArgs compile_args = get<3>(GetParam()); initMatrixRandU(type, sz_in, false); @@ -916,7 +920,9 @@ PERF_TEST_P_(SumPerfTest, TestPerformance) } // Comparison //////////////////////////////////////////////////////////// - EXPECT_EQ(out_sum[0], out_sum_ocv[0]); + { + EXPECT_LE(abs(out_sum[0] - out_sum_ocv[0]), tolerance); + } SANITY_CHECK_NOTHING(); } @@ -928,7 +934,8 @@ PERF_TEST_P_(AddWeightedPerfTest, TestPerformance) cv::Size sz_in = get<0>(GetParam()); MatType type = get<1>(GetParam()); int dtype = get<2>(GetParam()); - cv::GCompileArgs compile_args = get<3>(GetParam()); + double tolerance = get<3>(GetParam()); + cv::GCompileArgs compile_args = get<4>(GetParam()); auto& rng = cv::theRNG(); double alpha = rng.uniform(0.0, 1.0); @@ -953,8 +960,43 @@ PERF_TEST_P_(AddWeightedPerfTest, TestPerformance) } // Comparison //////////////////////////////////////////////////////////// - EXPECT_EQ(0, cv::countNonZero(out_mat_gapi != out_mat_ocv)); - EXPECT_EQ(out_mat_gapi.size(), sz_in); + { + // Note, that we cannot expect bitwise results for add-weighted: + // + // tmp = src1*alpha + src2*beta + gamma; + // dst = saturate( round(tmp) ); + // + // Because tmp is floating-point, dst depends on compiler optimizations + // + // However, we must expect good accuracy of tmp, and rounding correctly + + cv::Mat failures; + + if (out_mat_ocv.type() == CV_32FC1) + { + // result: float - may vary in 7th decimal digit + failures = abs(out_mat_gapi - out_mat_ocv) > abs(out_mat_ocv) * 1e-6; + } + else + { + // result: integral - rounding may vary if fractional part of tmp + // is nearly 0.5 + + cv::Mat inexact, incorrect, diff, tmp; + + inexact = out_mat_gapi != out_mat_ocv; + + // even if rounded differently, check if still rounded correctly + cv::addWeighted(in_mat1, alpha, in_mat2, beta, gamma, tmp, CV_32F); + cv::subtract(out_mat_gapi, tmp, diff, cv::noArray(), CV_32F); + incorrect = abs(diff) >= tolerance;// 0.5000005f; // relative to 6 digits + + failures = inexact & incorrect; + } + + EXPECT_EQ(0, cv::countNonZero(failures)); + EXPECT_EQ(out_mat_gapi.size(), sz_in); + } SANITY_CHECK_NOTHING(); } @@ -966,7 +1008,8 @@ PERF_TEST_P_(NormPerfTest, TestPerformance) NormTypes opType = get<0>(GetParam()); cv::Size sz = get<1>(GetParam()); MatType type = get<2>(GetParam()); - cv::GCompileArgs compile_args = get<3>(GetParam()); + double tolerance = get<3>(GetParam()); + cv::GCompileArgs compile_args = get<4>(GetParam()); initMatrixRandU(type, sz, type, false); @@ -997,7 +1040,9 @@ PERF_TEST_P_(NormPerfTest, TestPerformance) } // Comparison //////////////////////////////////////////////////////////// - EXPECT_EQ(out_norm[0], out_norm_ocv[0]); + { + EXPECT_LE(abs(out_norm[0] - out_norm_ocv[0]), tolerance); + } SANITY_CHECK_NOTHING(); } @@ -1696,11 +1741,11 @@ PERF_TEST_P_(ConvertToPerfTest, TestPerformance) PERF_TEST_P_(ResizePerfTest, TestPerformance) { - MatType type = get<0>(GetParam()); - int interp = get<1>(GetParam()); - cv::Size sz_in = get<2>(GetParam()); - cv::Size sz_out = get<3>(GetParam()); - double tolerance = get<4>(GetParam()); + compare_f cmpF = get<0>(GetParam()); + MatType type = get<1>(GetParam()); + int interp = get<2>(GetParam()); + cv::Size sz_in = get<3>(GetParam()); + cv::Size sz_out = get<4>(GetParam()); cv::GCompileArgs compile_args = get<5>(GetParam()); in_mat1 = cv::Mat(sz_in, type); @@ -1727,9 +1772,9 @@ PERF_TEST_P_(ResizePerfTest, TestPerformance) } // Comparison //////////////////////////////////////////////////////////// - cv::Mat absDiff; - cv::absdiff(out_mat_gapi, out_mat_ocv, absDiff); - EXPECT_EQ(0, cv::countNonZero(absDiff > tolerance)); + { + EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv)); + } SANITY_CHECK_NOTHING(); } @@ -1738,12 +1783,12 @@ PERF_TEST_P_(ResizePerfTest, TestPerformance) PERF_TEST_P_(ResizeFxFyPerfTest, TestPerformance) { - MatType type = get<0>(GetParam()); - int interp = get<1>(GetParam()); - cv::Size sz_in = get<2>(GetParam()); - double fx = get<3>(GetParam()); - double fy = get<4>(GetParam()); - double tolerance = get<5>(GetParam()); + compare_f cmpF = get<0>(GetParam()); + MatType type = get<1>(GetParam()); + int interp = get<2>(GetParam()); + cv::Size sz_in = get<3>(GetParam()); + double fx = get<4>(GetParam()); + double fy = get<5>(GetParam()); cv::GCompileArgs compile_args = get<6>(GetParam()); in_mat1 = cv::Mat(sz_in, type); @@ -1771,9 +1816,9 @@ PERF_TEST_P_(ResizeFxFyPerfTest, TestPerformance) } // Comparison //////////////////////////////////////////////////////////// - cv::Mat absDiff; - cv::absdiff(out_mat_gapi, out_mat_ocv, absDiff); - EXPECT_EQ(0, cv::countNonZero(absDiff > tolerance)); + { + EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv)); + } SANITY_CHECK_NOTHING(); } diff --git a/modules/gapi/perf/cpu/gapi_core_perf_tests_cpu.cpp b/modules/gapi/perf/cpu/gapi_core_perf_tests_cpu.cpp index aa358783b9..6957401adf 100644 --- a/modules/gapi/perf/cpu/gapi_core_perf_tests_cpu.cpp +++ b/modules/gapi/perf/cpu/gapi_core_perf_tests_cpu.cpp @@ -14,264 +14,273 @@ namespace opencv_test { - INSTANTIATE_TEST_CASE_P(AddPerfTestCPU, AddPerfTest, - Combine(Values(szSmall128, szVGA, sz720p, sz1080p), - Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), - Values(-1, CV_8U, CV_16U, CV_32F), - Values(cv::compile_args(CORE_CPU)))); - INSTANTIATE_TEST_CASE_P(AddCPerfTestCPU, AddCPerfTest, - Combine(Values(szSmall128, szVGA, sz720p, sz1080p), - Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), - Values(-1, CV_8U, CV_16U, CV_32F), - Values(cv::compile_args(CORE_CPU)))); +INSTANTIATE_TEST_CASE_P(AddPerfTestCPU, AddPerfTest, + Combine(Values(szSmall128, szVGA, sz720p, sz1080p), + Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), + Values(-1, CV_8U, CV_16U, CV_32F), + Values(cv::compile_args(CORE_CPU)))); - INSTANTIATE_TEST_CASE_P(SubPerfTestCPU, SubPerfTest, - Combine(Values(szSmall128, szVGA, sz720p, sz1080p), - Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), - Values(-1, CV_8U, CV_16U, CV_32F), - Values(cv::compile_args(CORE_CPU)))); +INSTANTIATE_TEST_CASE_P(AddCPerfTestCPU, AddCPerfTest, + Combine(Values(szSmall128, szVGA, sz720p, sz1080p), + Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), + Values(-1, CV_8U, CV_16U, CV_32F), + Values(cv::compile_args(CORE_CPU)))); - INSTANTIATE_TEST_CASE_P(SubCPerfTestCPU, SubCPerfTest, - Combine(Values(szSmall128, szVGA, sz720p, sz1080p), - Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), - Values(-1, CV_8U, CV_16U, CV_32F), - Values(cv::compile_args(CORE_CPU)))); +INSTANTIATE_TEST_CASE_P(SubPerfTestCPU, SubPerfTest, + Combine(Values(szSmall128, szVGA, sz720p, sz1080p), + Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), + Values(-1, CV_8U, CV_16U, CV_32F), + Values(cv::compile_args(CORE_CPU)))); - INSTANTIATE_TEST_CASE_P(SubRCPerfTestCPU, SubRCPerfTest, - Combine(Values(szSmall128, szVGA, sz720p, sz1080p), - Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), - Values(-1, CV_8U, CV_16U, CV_32F), - Values(cv::compile_args(CORE_CPU)))); +INSTANTIATE_TEST_CASE_P(SubCPerfTestCPU, SubCPerfTest, + Combine(Values(szSmall128, szVGA, sz720p, sz1080p), + Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), + Values(-1, CV_8U, CV_16U, CV_32F), + Values(cv::compile_args(CORE_CPU)))); - INSTANTIATE_TEST_CASE_P(MulPerfTestCPU, MulPerfTest, - Combine(Values(szSmall128, szVGA, sz720p, sz1080p), - Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), - Values(-1, CV_8U, CV_16U, CV_32F), - Values(cv::compile_args(CORE_CPU)))); +INSTANTIATE_TEST_CASE_P(SubRCPerfTestCPU, SubRCPerfTest, + Combine(Values(szSmall128, szVGA, sz720p, sz1080p), + Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), + Values(-1, CV_8U, CV_16U, CV_32F), + Values(cv::compile_args(CORE_CPU)))); - INSTANTIATE_TEST_CASE_P(MulDoublePerfTestCPU, MulDoublePerfTest, - Combine(Values(szSmall128, szVGA, sz720p, sz1080p), - Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), - Values(-1, CV_8U, CV_16U, CV_32F), - Values(cv::compile_args(CORE_CPU)))); +INSTANTIATE_TEST_CASE_P(MulPerfTestCPU, MulPerfTest, + Combine(Values(szSmall128, szVGA, sz720p, sz1080p), + Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), + Values(-1, CV_8U, CV_16U, CV_32F), + Values(cv::compile_args(CORE_CPU)))); - INSTANTIATE_TEST_CASE_P(MulCPerfTestCPU, MulCPerfTest, - Combine(Values(szSmall128, szVGA, sz720p, sz1080p), - Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), - Values(-1, CV_8U, CV_16U, CV_32F), - Values(cv::compile_args(CORE_CPU)))); +INSTANTIATE_TEST_CASE_P(MulDoublePerfTestCPU, MulDoublePerfTest, + Combine(Values(szSmall128, szVGA, sz720p, sz1080p), + Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), + Values(-1, CV_8U, CV_16U, CV_32F), + Values(cv::compile_args(CORE_CPU)))); - INSTANTIATE_TEST_CASE_P(DivPerfTestCPU, DivPerfTest, - Combine(Values(szSmall128, szVGA, sz720p, sz1080p), - Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), - Values(-1, CV_8U, CV_16U, CV_32F), - Values(cv::compile_args(CORE_CPU)))); +INSTANTIATE_TEST_CASE_P(MulCPerfTestCPU, MulCPerfTest, + Combine(Values(szSmall128, szVGA, sz720p, sz1080p), + Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), + Values(-1, CV_8U, CV_16U, CV_32F), + Values(cv::compile_args(CORE_CPU)))); - INSTANTIATE_TEST_CASE_P(DivCPerfTestCPU, DivCPerfTest, - Combine(Values(szSmall128, szVGA, sz720p, sz1080p), - Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), - Values(-1, CV_8U, CV_16U, CV_32F), - Values(cv::compile_args(CORE_CPU)))); +INSTANTIATE_TEST_CASE_P(DivPerfTestCPU, DivPerfTest, + Combine(Values(AbsExact().to_compare_f()), + Values(szSmall128, szVGA, sz720p, sz1080p), + Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), + Values(-1, CV_8U, CV_16U, CV_32F), + Values(cv::compile_args(CORE_CPU)))); - INSTANTIATE_TEST_CASE_P(DivRCPerfTestCPU, DivRCPerfTest, - Combine(Values(szSmall128, szVGA, sz720p, sz1080p), - Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), - Values(-1, CV_8U, CV_16U, CV_32F), - Values(cv::compile_args(CORE_CPU)))); +INSTANTIATE_TEST_CASE_P(DivCPerfTestCPU, DivCPerfTest, + Combine(Values(szSmall128, szVGA, sz720p, sz1080p), + Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), + Values(-1, CV_8U, CV_16U, CV_32F), + Values(cv::compile_args(CORE_CPU)))); - INSTANTIATE_TEST_CASE_P(MaskPerfTestCPU, MaskPerfTest, - Combine(Values(szSmall128, szVGA, sz720p, sz1080p), - Values(CV_8UC1, CV_16UC1, CV_16SC1), - Values(cv::compile_args(CORE_CPU)))); +INSTANTIATE_TEST_CASE_P(DivRCPerfTestCPU, DivRCPerfTest, + Combine(Values(AbsExact().to_compare_f()), + Values(szSmall128, szVGA, sz720p, sz1080p), + Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), + Values(-1, CV_8U, CV_16U, CV_32F), + Values(cv::compile_args(CORE_CPU)))); - INSTANTIATE_TEST_CASE_P(MeanPerfTestCPU, MeanPerfTest, - Combine(Values(szSmall128, szVGA, sz720p, sz1080p), - Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), - Values(cv::compile_args(CORE_CPU)))); +INSTANTIATE_TEST_CASE_P(MaskPerfTestCPU, MaskPerfTest, + Combine(Values(szSmall128, szVGA, sz720p, sz1080p), + Values(CV_8UC1, CV_16UC1, CV_16SC1), + Values(cv::compile_args(CORE_CPU)))); - INSTANTIATE_TEST_CASE_P(Polar2CartPerfTestCPU, Polar2CartPerfTest, - Combine(Values(szSmall128, szVGA, sz720p, sz1080p), - Values(cv::compile_args(CORE_CPU)))); +INSTANTIATE_TEST_CASE_P(MeanPerfTestCPU, MeanPerfTest, + Combine(Values(szSmall128, szVGA, sz720p, sz1080p), + Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), + Values(cv::compile_args(CORE_CPU)))); - INSTANTIATE_TEST_CASE_P(Cart2PolarPerfTestCPU, Cart2PolarPerfTest, - Combine(Values(szSmall128, szVGA, sz720p, sz1080p), - Values(cv::compile_args(CORE_CPU)))); +INSTANTIATE_TEST_CASE_P(Polar2CartPerfTestCPU, Polar2CartPerfTest, + Combine(Values(AbsExact().to_compare_f()), + Values(szSmall128, szVGA, sz720p, sz1080p), + Values(cv::compile_args(CORE_CPU)))); - INSTANTIATE_TEST_CASE_P(CmpPerfTestCPU, CmpPerfTest, - Combine(Values(CMP_EQ, CMP_GE, CMP_NE, CMP_GT, CMP_LT, CMP_LE), - Values(szSmall128, szVGA, sz720p, sz1080p), - Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), - Values(cv::compile_args(CORE_CPU)))); +INSTANTIATE_TEST_CASE_P(Cart2PolarPerfTestCPU, Cart2PolarPerfTest, + Combine(Values(AbsExact().to_compare_f()), + Values(szSmall128, szVGA, sz720p, sz1080p), + Values(cv::compile_args(CORE_CPU)))); - INSTANTIATE_TEST_CASE_P(CmpWithScalarPerfTestCPU, CmpWithScalarPerfTest, - Combine(Values(CMP_EQ, CMP_GE, CMP_NE, CMP_GT, CMP_LT, CMP_LE), - Values(szSmall128, szVGA, sz720p, sz1080p), - Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), - Values(cv::compile_args(CORE_CPU)))); +INSTANTIATE_TEST_CASE_P(CmpPerfTestCPU, CmpPerfTest, + Combine(Values(CMP_EQ, CMP_GE, CMP_NE, CMP_GT, CMP_LT, CMP_LE), + Values(szSmall128, szVGA, sz720p, sz1080p), + Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), + Values(cv::compile_args(CORE_CPU)))); - INSTANTIATE_TEST_CASE_P(BitwisePerfTestCPU, BitwisePerfTest, - Combine(Values(AND, OR, XOR), - Values(szSmall128, szVGA, sz720p, sz1080p), - Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1), - Values(cv::compile_args(CORE_CPU)))); +INSTANTIATE_TEST_CASE_P(CmpWithScalarPerfTestCPU, CmpWithScalarPerfTest, + Combine(Values(CMP_EQ, CMP_GE, CMP_NE, CMP_GT, CMP_LT, CMP_LE), + Values(szSmall128, szVGA, sz720p, sz1080p), + Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), + Values(cv::compile_args(CORE_CPU)))); - INSTANTIATE_TEST_CASE_P(BitwiseNotPerfTestCPU, BitwiseNotPerfTest, - Combine(Values(szSmall128, szVGA, sz720p, sz1080p), - Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), - Values(cv::compile_args(CORE_CPU)))); +INSTANTIATE_TEST_CASE_P(BitwisePerfTestCPU, BitwisePerfTest, + Combine(Values(AND, OR, XOR), + Values(szSmall128, szVGA, sz720p, sz1080p), + Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1), + Values(cv::compile_args(CORE_CPU)))); - INSTANTIATE_TEST_CASE_P(SelectPerfTestCPU, SelectPerfTest, - Combine(Values(szSmall128, szVGA, sz720p, sz1080p), - Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), - Values(cv::compile_args(CORE_CPU)))); +INSTANTIATE_TEST_CASE_P(BitwiseNotPerfTestCPU, BitwiseNotPerfTest, + Combine(Values(szSmall128, szVGA, sz720p, sz1080p), + Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), + Values(cv::compile_args(CORE_CPU)))); - INSTANTIATE_TEST_CASE_P(MinPerfTestCPU, MinPerfTest, - Combine(Values(szSmall128, szVGA, sz720p, sz1080p), - Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), - Values(cv::compile_args(CORE_CPU)))); +INSTANTIATE_TEST_CASE_P(SelectPerfTestCPU, SelectPerfTest, + Combine(Values(szSmall128, szVGA, sz720p, sz1080p), + Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), + Values(cv::compile_args(CORE_CPU)))); - INSTANTIATE_TEST_CASE_P(MaxPerfTestCPU, MaxPerfTest, - Combine(Values(szSmall128, szVGA, sz720p, sz1080p), - Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), - Values(cv::compile_args(CORE_CPU)))); +INSTANTIATE_TEST_CASE_P(MinPerfTestCPU, MinPerfTest, + Combine(Values(szSmall128, szVGA, sz720p, sz1080p), + Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), + Values(cv::compile_args(CORE_CPU)))); - INSTANTIATE_TEST_CASE_P(AbsDiffPerfTestCPU, AbsDiffPerfTest, - Combine(Values(szSmall128, szVGA, sz720p, sz1080p), - Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), - Values(cv::compile_args(CORE_CPU)))); +INSTANTIATE_TEST_CASE_P(MaxPerfTestCPU, MaxPerfTest, + Combine(Values(szSmall128, szVGA, sz720p, sz1080p), + Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), + Values(cv::compile_args(CORE_CPU)))); - INSTANTIATE_TEST_CASE_P(AbsDiffCPerfTestCPU, AbsDiffCPerfTest, - Combine(Values(szSmall128, szVGA, sz720p, sz1080p), - Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), - Values(cv::compile_args(CORE_CPU)))); +INSTANTIATE_TEST_CASE_P(AbsDiffPerfTestCPU, AbsDiffPerfTest, + Combine(Values(szSmall128, szVGA, sz720p, sz1080p), + Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), + Values(cv::compile_args(CORE_CPU)))); - INSTANTIATE_TEST_CASE_P(SumPerfTestCPU, SumPerfTest, - Combine(Values(szSmall128, szVGA, sz720p, sz1080p), - Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), - Values(cv::compile_args(CORE_CPU)))); +INSTANTIATE_TEST_CASE_P(AbsDiffCPerfTestCPU, AbsDiffCPerfTest, + Combine(Values(szSmall128, szVGA, sz720p, sz1080p), + Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), + Values(cv::compile_args(CORE_CPU)))); - INSTANTIATE_TEST_CASE_P(AddWeightedPerfTestCPU, AddWeightedPerfTest, - Combine(Values(szSmall128, szVGA, sz720p, sz1080p), - Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), - Values(-1, CV_8U, CV_16U, CV_32F), - Values(cv::compile_args(CORE_CPU)))); +INSTANTIATE_TEST_CASE_P(SumPerfTestCPU, SumPerfTest, + Combine(Values(szSmall128, szVGA, sz720p, sz1080p), + Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), + Values(0.0), + Values(cv::compile_args(CORE_CPU)))); - INSTANTIATE_TEST_CASE_P(NormPerfTestCPU, NormPerfTest, - Combine(Values(NORM_INF, NORM_L1, NORM_L2), - Values(szSmall128, szVGA, sz720p, sz1080p), - Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), - Values(cv::compile_args(CORE_CPU)))); +// FIXME: Comparison introduced by YL doesn't work with C3 +INSTANTIATE_TEST_CASE_P(AddWeightedPerfTestCPU, AddWeightedPerfTest, + Combine(Values(szSmall128, szVGA, sz720p, sz1080p), + Values(CV_8UC1, /*CV_8UC3,*/ CV_16UC1, CV_16SC1, CV_32FC1), + Values(-1, CV_8U, CV_16U, CV_32F), + Values(0.5000005), + Values(cv::compile_args(CORE_CPU)))); - INSTANTIATE_TEST_CASE_P(IntegralPerfTestCPU, IntegralPerfTest, - Combine(Values(szSmall128, szVGA, sz720p, sz1080p), - Values(CV_8UC1, CV_16UC1, CV_16SC1, CV_32FC1), - Values(cv::compile_args(CORE_CPU)))); +INSTANTIATE_TEST_CASE_P(NormPerfTestCPU, NormPerfTest, + Combine(Values(NORM_INF, NORM_L1, NORM_L2), + Values(szSmall128, szVGA, sz720p, sz1080p), + Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), + Values(0.0), + Values(cv::compile_args(CORE_CPU)))); - INSTANTIATE_TEST_CASE_P(ThresholdPerfTestCPU, ThresholdPerfTest, - Combine(Values(szSmall128, szVGA, sz720p, sz1080p), - Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), - Values(cv::THRESH_BINARY, cv::THRESH_BINARY_INV, cv::THRESH_TRUNC, cv::THRESH_TOZERO, cv::THRESH_TOZERO_INV), - Values(cv::compile_args(CORE_CPU)))); +INSTANTIATE_TEST_CASE_P(IntegralPerfTestCPU, IntegralPerfTest, + Combine(Values(szSmall128, szVGA, sz720p, sz1080p), + Values(CV_8UC1, CV_16UC1, CV_16SC1, CV_32FC1), + Values(cv::compile_args(CORE_CPU)))); - INSTANTIATE_TEST_CASE_P(ThresholdPerfTestCPU, ThresholdOTPerfTest, - Combine(Values(szSmall128, szVGA, sz720p, sz1080p), - Values(CV_8UC1), - Values(cv::THRESH_OTSU, cv::THRESH_TRIANGLE), - Values(cv::compile_args(CORE_CPU)))); +INSTANTIATE_TEST_CASE_P(ThresholdPerfTestCPU, ThresholdPerfTest, + Combine(Values(szSmall128, szVGA, sz720p, sz1080p), + Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), + Values(cv::THRESH_BINARY, cv::THRESH_BINARY_INV, cv::THRESH_TRUNC, cv::THRESH_TOZERO, cv::THRESH_TOZERO_INV), + Values(cv::compile_args(CORE_CPU)))); - INSTANTIATE_TEST_CASE_P(InRangePerfTestCPU, InRangePerfTest, - Combine(Values(szSmall128, szVGA, sz720p, sz1080p), - Values(CV_8UC1), - Values(cv::compile_args(CORE_CPU)))); +INSTANTIATE_TEST_CASE_P(ThresholdPerfTestCPU, ThresholdOTPerfTest, + Combine(Values(szSmall128, szVGA, sz720p, sz1080p), + Values(CV_8UC1), + Values(cv::THRESH_OTSU, cv::THRESH_TRIANGLE), + Values(cv::compile_args(CORE_CPU)))); - INSTANTIATE_TEST_CASE_P(Split3PerfTestCPU, Split3PerfTest, - Combine(Values(szSmall128, szVGA, sz720p, sz1080p), - Values(cv::compile_args(CORE_CPU)))); +INSTANTIATE_TEST_CASE_P(InRangePerfTestCPU, InRangePerfTest, + Combine(Values(szSmall128, szVGA, sz720p, sz1080p), + Values(CV_8UC1), + Values(cv::compile_args(CORE_CPU)))); - INSTANTIATE_TEST_CASE_P(Split4PerfTestCPU, Split4PerfTest, - Combine(Values(szSmall128, szVGA, sz720p, sz1080p), - Values(cv::compile_args(CORE_CPU)))); +INSTANTIATE_TEST_CASE_P(Split3PerfTestCPU, Split3PerfTest, + Combine(Values(szSmall128, szVGA, sz720p, sz1080p), + Values(cv::compile_args(CORE_CPU)))); - INSTANTIATE_TEST_CASE_P(Merge3PerfTestCPU, Merge3PerfTest, - Combine(Values(szSmall128, szVGA, sz720p, sz1080p), - Values(cv::compile_args(CORE_CPU)))); +INSTANTIATE_TEST_CASE_P(Split4PerfTestCPU, Split4PerfTest, + Combine(Values(szSmall128, szVGA, sz720p, sz1080p), + Values(cv::compile_args(CORE_CPU)))); - INSTANTIATE_TEST_CASE_P(Merge4PerfTestCPU, Merge4PerfTest, - Combine(Values(szSmall128, szVGA, sz720p, sz1080p), - Values(cv::compile_args(CORE_CPU)))); +INSTANTIATE_TEST_CASE_P(Merge3PerfTestCPU, Merge3PerfTest, + Combine(Values(szSmall128, szVGA, sz720p, sz1080p), + Values(cv::compile_args(CORE_CPU)))); - INSTANTIATE_TEST_CASE_P(RemapPerfTestCPU, RemapPerfTest, - Combine(Values(szSmall128, szVGA, sz720p, sz1080p), - Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), - Values(cv::compile_args(CORE_CPU)))); +INSTANTIATE_TEST_CASE_P(Merge4PerfTestCPU, Merge4PerfTest, + Combine(Values(szSmall128, szVGA, sz720p, sz1080p), + Values(cv::compile_args(CORE_CPU)))); - INSTANTIATE_TEST_CASE_P(FlipPerfTestCPU, FlipPerfTest, - Combine(Values(szSmall128, szVGA, sz720p, sz1080p), - Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), - Values(0, 1, -1), - Values(cv::compile_args(CORE_CPU)))); +INSTANTIATE_TEST_CASE_P(RemapPerfTestCPU, RemapPerfTest, + Combine(Values(szSmall128, szVGA, sz720p, sz1080p), + Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), + Values(cv::compile_args(CORE_CPU)))); - INSTANTIATE_TEST_CASE_P(CropPerfTestCPU, CropPerfTest, - Combine(Values(szSmall128, szVGA, sz720p, sz1080p), - Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), - Values(cv::Rect(10, 8, 20, 35), cv::Rect(4, 10, 37, 50)), - Values(cv::compile_args(CORE_CPU)))); +INSTANTIATE_TEST_CASE_P(FlipPerfTestCPU, FlipPerfTest, + Combine(Values(szSmall128, szVGA, sz720p, sz1080p), + Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), + Values(0, 1, -1), + Values(cv::compile_args(CORE_CPU)))); - INSTANTIATE_TEST_CASE_P(ConcatHorPerfTestCPU, ConcatHorPerfTest, - Combine(Values(szSmall128, szVGA, sz720p, sz1080p), - Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), - Values(cv::compile_args(CORE_CPU)))); +INSTANTIATE_TEST_CASE_P(CropPerfTestCPU, CropPerfTest, + Combine(Values(szSmall128, szVGA, sz720p, sz1080p), + Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), + Values(cv::Rect(10, 8, 20, 35), cv::Rect(4, 10, 37, 50)), + Values(cv::compile_args(CORE_CPU)))); - INSTANTIATE_TEST_CASE_P(ConcatHorVecPerfTestCPU, ConcatHorVecPerfTest, - Combine(Values(szSmall128, szVGA, sz720p, sz1080p), - Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), - Values(cv::compile_args(CORE_CPU)))); +INSTANTIATE_TEST_CASE_P(ConcatHorPerfTestCPU, ConcatHorPerfTest, + Combine(Values(szSmall128, szVGA, sz720p, sz1080p), + Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), + Values(cv::compile_args(CORE_CPU)))); - INSTANTIATE_TEST_CASE_P(ConcatVertPerfTestCPU, ConcatVertPerfTest, - Combine(Values(szSmall128, szVGA, sz720p, sz1080p), - Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), - Values(cv::compile_args(CORE_CPU)))); +INSTANTIATE_TEST_CASE_P(ConcatHorVecPerfTestCPU, ConcatHorVecPerfTest, + Combine(Values(szSmall128, szVGA, sz720p, sz1080p), + Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), + Values(cv::compile_args(CORE_CPU)))); - INSTANTIATE_TEST_CASE_P(ConcatVertVecPerfTestCPU, ConcatVertVecPerfTest, - Combine(Values(szSmall128, szVGA, sz720p, sz1080p), - Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), - Values(cv::compile_args(CORE_CPU)))); +INSTANTIATE_TEST_CASE_P(ConcatVertPerfTestCPU, ConcatVertPerfTest, + Combine(Values(szSmall128, szVGA, sz720p, sz1080p), + Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), + Values(cv::compile_args(CORE_CPU)))); - INSTANTIATE_TEST_CASE_P(LUTPerfTestCPU, LUTPerfTest, - Combine(Values(CV_8UC1, CV_8UC3), - Values(CV_8UC1), - Values(szSmall128, szVGA, sz720p, sz1080p), - Values(cv::compile_args(CORE_CPU)))); +INSTANTIATE_TEST_CASE_P(ConcatVertVecPerfTestCPU, ConcatVertVecPerfTest, + Combine(Values(szSmall128, szVGA, sz720p, sz1080p), + Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), + Values(cv::compile_args(CORE_CPU)))); - INSTANTIATE_TEST_CASE_P(LUTPerfTestCustomCPU, LUTPerfTest, - Combine(Values(CV_8UC3), - Values(CV_8UC3), - Values(szSmall128, szVGA, sz720p, sz1080p), - Values(cv::compile_args(CORE_CPU)))); +INSTANTIATE_TEST_CASE_P(LUTPerfTestCPU, LUTPerfTest, + Combine(Values(CV_8UC1, CV_8UC3), + Values(CV_8UC1), + Values(szSmall128, szVGA, sz720p, sz1080p), + Values(cv::compile_args(CORE_CPU)))); + +INSTANTIATE_TEST_CASE_P(LUTPerfTestCustomCPU, LUTPerfTest, + Combine(Values(CV_8UC3), + Values(CV_8UC3), + Values(szSmall128, szVGA, sz720p, sz1080p), + Values(cv::compile_args(CORE_CPU)))); - INSTANTIATE_TEST_CASE_P(ConvertToPerfTestCPU, ConvertToPerfTest, - Combine(Values(CV_8UC3, CV_8UC1, CV_16UC1, CV_32FC1), - Values(CV_8U, CV_16U, CV_16S, CV_32F), - Values(szSmall128, szVGA, sz720p, sz1080p), - Values(cv::compile_args(CORE_CPU)))); +INSTANTIATE_TEST_CASE_P(ConvertToPerfTestCPU, ConvertToPerfTest, + Combine(Values(CV_8UC3, CV_8UC1, CV_16UC1, CV_32FC1), + Values(CV_8U, CV_16U, CV_16S, CV_32F), + Values(szSmall128, szVGA, sz720p, sz1080p), + Values(cv::compile_args(CORE_CPU)))); - INSTANTIATE_TEST_CASE_P(ResizePerfTestCPU, ResizePerfTest, - Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1), - Values(cv::INTER_NEAREST, cv::INTER_LINEAR, cv::INTER_AREA), - Values(szSmall128, szVGA, sz720p, sz1080p), - Values(cv::Size(64, 64), - cv::Size(30, 30)), - Values(0.0), - Values(cv::compile_args(CORE_CPU)))); +INSTANTIATE_TEST_CASE_P(ResizePerfTestCPU, ResizePerfTest, + Combine(Values(AbsExact().to_compare_f()), + Values(CV_8UC1, CV_16UC1, CV_16SC1), + Values(cv::INTER_NEAREST, cv::INTER_LINEAR, cv::INTER_AREA), + Values(szSmall128, szVGA, sz720p, sz1080p), + Values(cv::Size(64, 64), + cv::Size(30, 30)), + Values(cv::compile_args(CORE_CPU)))); - INSTANTIATE_TEST_CASE_P(ResizeFxFyPerfTestCPU, ResizeFxFyPerfTest, - Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1), - Values(cv::INTER_NEAREST, cv::INTER_LINEAR, cv::INTER_AREA), - Values(szSmall128, szVGA, sz720p, sz1080p), - Values(0.5, 0.1), - Values(0.5, 0.1), - Values(0.0), - Values(cv::compile_args(CORE_CPU)))); +INSTANTIATE_TEST_CASE_P(ResizeFxFyPerfTestCPU, ResizeFxFyPerfTest, + Combine(Values(AbsExact().to_compare_f()), + Values(CV_8UC1, CV_16UC1, CV_16SC1), + Values(cv::INTER_NEAREST, cv::INTER_LINEAR, cv::INTER_AREA), + Values(szSmall128, szVGA, sz720p, sz1080p), + Values(0.5, 0.1), + Values(0.5, 0.1), + Values(cv::compile_args(CORE_CPU)))); } diff --git a/modules/gapi/perf/cpu/gapi_imgproc_perf_tests_cpu.cpp b/modules/gapi/perf/cpu/gapi_imgproc_perf_tests_cpu.cpp index 23180123ed..a4312de855 100644 --- a/modules/gapi/perf/cpu/gapi_imgproc_perf_tests_cpu.cpp +++ b/modules/gapi/perf/cpu/gapi_imgproc_perf_tests_cpu.cpp @@ -15,188 +15,166 @@ namespace opencv_test { - class AbsExact : public Wrappable - { - public: - AbsExact() {} - bool operator() (const cv::Mat& in1, const cv::Mat& in2) const { return cv::countNonZero(in1 != in2) == 0; } - private: - }; +INSTANTIATE_TEST_CASE_P(SepFilterPerfTestCPU_8U, SepFilterPerfTest, + Combine(Values(AbsExact().to_compare_f()), + Values(CV_8UC1, CV_8UC3), + Values(3), + Values(szVGA, sz720p, sz1080p), + Values(-1, CV_16S, CV_32F), + Values(cv::compile_args(IMGPROC_CPU)))); - class AbsTolerance : public Wrappable - { - public: - AbsTolerance(double tol) : _tol(tol) {} - bool operator() (const cv::Mat& in1, const cv::Mat& in2) const - { - cv::Mat absDiff; cv::absdiff(in1, in2, absDiff); - return cv::countNonZero(absDiff > _tol) == 0; - } - private: - double _tol; - }; - - - INSTANTIATE_TEST_CASE_P(SepFilterPerfTestCPU_8U, SepFilterPerfTest, - Combine(Values(AbsExact().to_compare_f()), - Values(CV_8UC1, CV_8UC3), - Values(3), - Values(szVGA, sz720p, sz1080p), - Values(-1, CV_16S, CV_32F), - Values(cv::compile_args(IMGPROC_CPU)))); - - INSTANTIATE_TEST_CASE_P(SepFilterPerfTestCPU_other, SepFilterPerfTest, - Combine(Values(AbsExact().to_compare_f()), - Values(CV_16UC1, CV_16SC1, CV_32FC1), - Values(3), - Values(szVGA, sz720p, sz1080p), - Values(-1, CV_32F), - Values(cv::compile_args(IMGPROC_CPU)))); +INSTANTIATE_TEST_CASE_P(SepFilterPerfTestCPU_other, SepFilterPerfTest, + Combine(Values(AbsExact().to_compare_f()), + Values(CV_16UC1, CV_16SC1, CV_32FC1), + Values(3), + Values(szVGA, sz720p, sz1080p), + Values(-1, CV_32F), + Values(cv::compile_args(IMGPROC_CPU)))); - INSTANTIATE_TEST_CASE_P(Filter2DPerfTestCPU, Filter2DPerfTest, - Combine(Values(AbsExact().to_compare_f()), - Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), - Values(3, 4, 5, 7), - Values(szVGA, sz720p, sz1080p), - Values(cv::BORDER_DEFAULT), - Values(-1, CV_32F), - Values(cv::compile_args(IMGPROC_CPU)))); +INSTANTIATE_TEST_CASE_P(Filter2DPerfTestCPU, Filter2DPerfTest, + Combine(Values(AbsExact().to_compare_f()), + Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), + Values(3, 4, 5, 7), + Values(szVGA, sz720p, sz1080p), + Values(cv::BORDER_DEFAULT), + Values(-1, CV_32F), + Values(cv::compile_args(IMGPROC_CPU)))); - INSTANTIATE_TEST_CASE_P(BoxFilterPerfTestCPU, BoxFilterPerfTest, - Combine(Values(AbsTolerance(1e-6).to_compare_f()), - Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), - Values(3, 5), - Values(szVGA, sz720p, sz1080p), - Values(cv::BORDER_DEFAULT), - Values(-1, CV_32F), - Values(cv::compile_args(IMGPROC_CPU)))); +INSTANTIATE_TEST_CASE_P(BoxFilterPerfTestCPU, BoxFilterPerfTest, + Combine(Values(AbsTolerance(0).to_compare_f()), + Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), + Values(3, 5), + Values(szVGA, sz720p, sz1080p), + Values(cv::BORDER_DEFAULT), + Values(-1, CV_32F), + Values(cv::compile_args(IMGPROC_CPU)))); - INSTANTIATE_TEST_CASE_P(BlurPerfTestCPU, BlurPerfTest, - Combine(Values(AbsTolerance(1e-6).to_compare_f()), - Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), - Values(3, 5), - Values(szVGA, sz720p, sz1080p), - Values(cv::BORDER_DEFAULT), - Values(cv::compile_args(IMGPROC_CPU)))); +INSTANTIATE_TEST_CASE_P(BlurPerfTestCPU, BlurPerfTest, + Combine(Values(AbsTolerance(0).to_compare_f()), + Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), + Values(3, 5), + Values(szVGA, sz720p, sz1080p), + Values(cv::BORDER_DEFAULT), + Values(cv::compile_args(IMGPROC_CPU)))); - INSTANTIATE_TEST_CASE_P(GaussianBlurPerfTestCPU, GaussianBlurPerfTest, - Combine(Values(AbsExact().to_compare_f()), - Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), - Values(3, 5), - Values(szVGA, sz720p, sz1080p), - Values(cv::compile_args(IMGPROC_CPU)))); +INSTANTIATE_TEST_CASE_P(GaussianBlurPerfTestCPU, GaussianBlurPerfTest, + Combine(Values(AbsExact().to_compare_f()), + Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), + Values(3, 5), + Values(szVGA, sz720p, sz1080p), + Values(cv::compile_args(IMGPROC_CPU)))); - INSTANTIATE_TEST_CASE_P(MedianBlurPerfTestCPU, MedianBlurPerfTest, - Combine(Values(AbsExact().to_compare_f()), - Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), - Values(3, 5), - Values(szVGA, sz720p, sz1080p), - Values(cv::compile_args(IMGPROC_CPU)))); +INSTANTIATE_TEST_CASE_P(MedianBlurPerfTestCPU, MedianBlurPerfTest, + Combine(Values(AbsExact().to_compare_f()), + Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), + Values(3, 5), + Values(szVGA, sz720p, sz1080p), + Values(cv::compile_args(IMGPROC_CPU)))); - INSTANTIATE_TEST_CASE_P(ErodePerfTestCPU, ErodePerfTest, - Combine(Values(AbsExact().to_compare_f()), - Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), - Values(3, 5), - Values(szVGA, sz720p, sz1080p), - Values(cv::MorphShapes::MORPH_RECT, - cv::MorphShapes::MORPH_CROSS, - cv::MorphShapes::MORPH_ELLIPSE), - Values(cv::compile_args(IMGPROC_CPU)))); +INSTANTIATE_TEST_CASE_P(ErodePerfTestCPU, ErodePerfTest, + Combine(Values(AbsExact().to_compare_f()), + Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), + Values(3, 5), + Values(szVGA, sz720p, sz1080p), + Values(cv::MorphShapes::MORPH_RECT, + cv::MorphShapes::MORPH_CROSS, + cv::MorphShapes::MORPH_ELLIPSE), + Values(cv::compile_args(IMGPROC_CPU)))); - INSTANTIATE_TEST_CASE_P(Erode3x3PerfTestCPU, Erode3x3PerfTest, - Combine(Values(AbsExact().to_compare_f()), - Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), - Values(szVGA, sz720p, sz1080p), - Values(1, 2, 4), - Values(cv::compile_args(IMGPROC_CPU)))); +INSTANTIATE_TEST_CASE_P(Erode3x3PerfTestCPU, Erode3x3PerfTest, + Combine(Values(AbsExact().to_compare_f()), + Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), + Values(szVGA, sz720p, sz1080p), + Values(1, 2, 4), + Values(cv::compile_args(IMGPROC_CPU)))); - INSTANTIATE_TEST_CASE_P(DilatePerfTestCPU, DilatePerfTest, - Combine(Values(AbsExact().to_compare_f()), - Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), - Values(3, 5), - Values(szVGA, sz720p, sz1080p), - Values(cv::MorphShapes::MORPH_RECT, - cv::MorphShapes::MORPH_CROSS, - cv::MorphShapes::MORPH_ELLIPSE), - Values(cv::compile_args(IMGPROC_CPU)))); +INSTANTIATE_TEST_CASE_P(DilatePerfTestCPU, DilatePerfTest, + Combine(Values(AbsExact().to_compare_f()), + Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), + Values(3, 5), + Values(szVGA, sz720p, sz1080p), + Values(cv::MorphShapes::MORPH_RECT, + cv::MorphShapes::MORPH_CROSS, + cv::MorphShapes::MORPH_ELLIPSE), + Values(cv::compile_args(IMGPROC_CPU)))); - INSTANTIATE_TEST_CASE_P(Dilate3x3PerfTestCPU, Dilate3x3PerfTest, - Combine(Values(AbsExact().to_compare_f()), - Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), - Values(szVGA, sz720p, sz1080p), - Values(1, 2, 4), - Values(cv::compile_args(IMGPROC_CPU)))); +INSTANTIATE_TEST_CASE_P(Dilate3x3PerfTestCPU, Dilate3x3PerfTest, + Combine(Values(AbsExact().to_compare_f()), + Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), + Values(szVGA, sz720p, sz1080p), + Values(1, 2, 4), + Values(cv::compile_args(IMGPROC_CPU)))); - INSTANTIATE_TEST_CASE_P(SobelPerfTestCPU, SobelPerfTest, - Combine(Values(AbsExact().to_compare_f()), - Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), - Values(3, 5), - Values(szVGA, sz720p, sz1080p), - Values(-1, CV_32F), - Values(0, 1), - Values(1, 2), - Values(cv::compile_args(IMGPROC_CPU)))); +INSTANTIATE_TEST_CASE_P(SobelPerfTestCPU, SobelPerfTest, + Combine(Values(AbsExact().to_compare_f()), + Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), + Values(3, 5), + Values(szVGA, sz720p, sz1080p), + Values(-1, CV_32F), + Values(0, 1), + Values(1, 2), + Values(cv::compile_args(IMGPROC_CPU)))); - INSTANTIATE_TEST_CASE_P(CannyPerfTestCPU, CannyPerfTest, - Combine(Values(AbsExact().to_compare_f()), - Values(CV_8UC1, CV_8UC3), - Values(szVGA, sz720p, sz1080p), - Values(3.0, 120.0), - Values(125.0, 240.0), - Values(3, 5), - Values(true, false), - Values(cv::compile_args(IMGPROC_CPU)))); +INSTANTIATE_TEST_CASE_P(CannyPerfTestCPU, CannyPerfTest, + Combine(Values(AbsExact().to_compare_f()), + Values(CV_8UC1, CV_8UC3), + Values(szVGA, sz720p, sz1080p), + Values(3.0, 120.0), + Values(125.0, 240.0), + Values(3, 5), + Values(true, false), + Values(cv::compile_args(IMGPROC_CPU)))); - INSTANTIATE_TEST_CASE_P(EqHistPerfTestCPU, EqHistPerfTest, - Combine(Values(AbsExact().to_compare_f()), - Values(szVGA, sz720p, sz1080p), - Values(cv::compile_args(IMGPROC_CPU)))); +INSTANTIATE_TEST_CASE_P(EqHistPerfTestCPU, EqHistPerfTest, + Combine(Values(AbsExact().to_compare_f()), + Values(szVGA, sz720p, sz1080p), + Values(cv::compile_args(IMGPROC_CPU)))); - INSTANTIATE_TEST_CASE_P(RGB2GrayPerfTestCPU, RGB2GrayPerfTest, - Combine(Values(AbsExact().to_compare_f()), - Values(szVGA, sz720p, sz1080p), - Values(cv::compile_args(IMGPROC_CPU)))); +INSTANTIATE_TEST_CASE_P(RGB2GrayPerfTestCPU, RGB2GrayPerfTest, + Combine(Values(AbsExact().to_compare_f()), + Values(szVGA, sz720p, sz1080p), + Values(cv::compile_args(IMGPROC_CPU)))); - INSTANTIATE_TEST_CASE_P(BGR2GrayPerfTestCPU, BGR2GrayPerfTest, - Combine(Values(AbsExact().to_compare_f()), - Values(szVGA, sz720p, sz1080p), - Values(cv::compile_args(IMGPROC_CPU)))); +INSTANTIATE_TEST_CASE_P(BGR2GrayPerfTestCPU, BGR2GrayPerfTest, + Combine(Values(AbsExact().to_compare_f()), + Values(szVGA, sz720p, sz1080p), + Values(cv::compile_args(IMGPROC_CPU)))); - INSTANTIATE_TEST_CASE_P(RGB2YUVPerfTestCPU, RGB2YUVPerfTest, - Combine(Values(AbsExact().to_compare_f()), - Values(szVGA, sz720p, sz1080p), - Values(cv::compile_args(IMGPROC_CPU)))); +INSTANTIATE_TEST_CASE_P(RGB2YUVPerfTestCPU, RGB2YUVPerfTest, + Combine(Values(AbsExact().to_compare_f()), + Values(szVGA, sz720p, sz1080p), + Values(cv::compile_args(IMGPROC_CPU)))); - INSTANTIATE_TEST_CASE_P(YUV2RGBPerfTestCPU, YUV2RGBPerfTest, - Combine(Values(AbsExact().to_compare_f()), - Values(szVGA, sz720p, sz1080p), - Values(cv::compile_args(IMGPROC_CPU)))); +INSTANTIATE_TEST_CASE_P(YUV2RGBPerfTestCPU, YUV2RGBPerfTest, + Combine(Values(AbsExact().to_compare_f()), + Values(szVGA, sz720p, sz1080p), + Values(cv::compile_args(IMGPROC_CPU)))); - INSTANTIATE_TEST_CASE_P(RGB2LabPerfTestCPU, RGB2LabPerfTest, - Combine(Values(AbsExact().to_compare_f()), - Values(szVGA, sz720p, sz1080p), - Values(cv::compile_args(IMGPROC_CPU)))); +INSTANTIATE_TEST_CASE_P(RGB2LabPerfTestCPU, RGB2LabPerfTest, + Combine(Values(AbsExact().to_compare_f()), + Values(szVGA, sz720p, sz1080p), + Values(cv::compile_args(IMGPROC_CPU)))); - INSTANTIATE_TEST_CASE_P(BGR2LUVPerfTestCPU, BGR2LUVPerfTest, - Combine(Values(AbsExact().to_compare_f()), - Values(szVGA, sz720p, sz1080p), - Values(cv::compile_args(IMGPROC_CPU)))); +INSTANTIATE_TEST_CASE_P(BGR2LUVPerfTestCPU, BGR2LUVPerfTest, + Combine(Values(AbsExact().to_compare_f()), + Values(szVGA, sz720p, sz1080p), + Values(cv::compile_args(IMGPROC_CPU)))); - INSTANTIATE_TEST_CASE_P(LUV2BGRPerfTestCPU, LUV2BGRPerfTest, - Combine(Values(AbsExact().to_compare_f()), - Values(szVGA, sz720p, sz1080p), - Values(cv::compile_args(IMGPROC_CPU)))); +INSTANTIATE_TEST_CASE_P(LUV2BGRPerfTestCPU, LUV2BGRPerfTest, + Combine(Values(AbsExact().to_compare_f()), + Values(szVGA, sz720p, sz1080p), + Values(cv::compile_args(IMGPROC_CPU)))); - INSTANTIATE_TEST_CASE_P(BGR2YUVPerfTestCPU, BGR2YUVPerfTest, - Combine(Values(AbsExact().to_compare_f()), - Values(szVGA, sz720p, sz1080p), - Values(cv::compile_args(IMGPROC_CPU)))); +INSTANTIATE_TEST_CASE_P(BGR2YUVPerfTestCPU, BGR2YUVPerfTest, + Combine(Values(AbsExact().to_compare_f()), + Values(szVGA, sz720p, sz1080p), + Values(cv::compile_args(IMGPROC_CPU)))); - INSTANTIATE_TEST_CASE_P(YUV2BGRPerfTestCPU, YUV2BGRPerfTest, - Combine(Values(AbsExact().to_compare_f()), - Values(szVGA, sz720p, sz1080p), - Values(cv::compile_args(IMGPROC_CPU)))); +INSTANTIATE_TEST_CASE_P(YUV2BGRPerfTestCPU, YUV2BGRPerfTest, + Combine(Values(AbsExact().to_compare_f()), + Values(szVGA, sz720p, sz1080p), + Values(cv::compile_args(IMGPROC_CPU)))); } diff --git a/modules/gapi/perf/gpu/gapi_core_perf_tests_gpu.cpp b/modules/gapi/perf/gpu/gapi_core_perf_tests_gpu.cpp new file mode 100644 index 0000000000..fa7f00d425 --- /dev/null +++ b/modules/gapi/perf/gpu/gapi_core_perf_tests_gpu.cpp @@ -0,0 +1,291 @@ +// This file is part of OpenCV project. +// It is subject to the license terms in the LICENSE file found in the top-level directory +// of this distribution and at http://opencv.org/license.html. +// +// Copyright (C) 2018 Intel Corporation + + +#include "../perf_precomp.hpp" +#include "../common/gapi_core_perf_tests.hpp" +#include "opencv2/gapi/gpu/core.hpp" + +#define CORE_GPU cv::gapi::core::gpu::kernels() + +namespace opencv_test +{ + +INSTANTIATE_TEST_CASE_P(AddPerfTestGPU, AddPerfTest, + Combine(Values( szSmall128, szVGA, sz720p, sz1080p ), + Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ), + Values( -1, CV_8U, CV_16U, CV_32F ), + Values(cv::compile_args(CORE_GPU)))); + +INSTANTIATE_TEST_CASE_P(AddCPerfTestGPU, AddCPerfTest, + Combine(Values( szSmall128, szVGA, sz720p, sz1080p ), + Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ), + Values( -1, CV_8U, CV_16U, CV_32F ), + Values(cv::compile_args(CORE_GPU)))); + +INSTANTIATE_TEST_CASE_P(SubPerfTestGPU, SubPerfTest, + Combine(Values( szSmall128, szVGA, sz720p, sz1080p ), + Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ), + Values( -1, CV_8U, CV_16U, CV_32F ), + Values(cv::compile_args(CORE_GPU)))); + +INSTANTIATE_TEST_CASE_P(SubCPerfTestGPU, SubCPerfTest, + Combine(Values( szSmall128, szVGA, sz720p, sz1080p ), + Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ), + Values( -1, CV_8U, CV_16U, CV_32F ), + Values(cv::compile_args(CORE_GPU)))); + +INSTANTIATE_TEST_CASE_P(SubRCPerfTestGPU, SubRCPerfTest, + Combine(Values( szSmall128, szVGA, sz720p, sz1080p ), + Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ), + Values( -1, CV_8U, CV_16U, CV_32F ), + Values(cv::compile_args(CORE_GPU)))); + +INSTANTIATE_TEST_CASE_P(MulPerfTestGPU, MulPerfTest, + Combine(Values( szSmall128, szVGA, sz720p, sz1080p ), + Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ), + Values( -1, CV_8U, CV_16U, CV_32F ), + Values(cv::compile_args(CORE_GPU)))); + +INSTANTIATE_TEST_CASE_P(MulDoublePerfTestGPU, MulDoublePerfTest, + Combine(Values( szSmall128, szVGA, sz720p, sz1080p ), + Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ), + Values( -1, CV_8U, CV_16U, CV_32F ), + Values(cv::compile_args(CORE_GPU)))); + +INSTANTIATE_TEST_CASE_P(MulCPerfTestGPU, MulCPerfTest, + Combine(Values( szSmall128, szVGA, sz720p, sz1080p ), + Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ), + Values( -1, CV_8U, CV_16U, CV_32F ), + Values(cv::compile_args(CORE_GPU)))); + +INSTANTIATE_TEST_CASE_P(DivPerfTestGPU, DivPerfTest, + Combine(Values(AbsTolerance_Float_Int(1e-5, 1e-2).to_compare_f()), + Values( szSmall128, szVGA, sz720p, sz1080p ), + Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ), + Values( -1, CV_8U, CV_16U, CV_32F ), + Values(cv::compile_args(CORE_GPU)))); + +INSTANTIATE_TEST_CASE_P(DivCPerfTestGPU, DivCPerfTest, + Combine(Values( szSmall128, szVGA, sz720p, sz1080p ), + Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ), + Values( -1, CV_8U, CV_16U, CV_32F ), + Values(cv::compile_args(CORE_GPU)))); + +INSTANTIATE_TEST_CASE_P(DivRCPerfTestGPU, DivRCPerfTest, + Combine(Values(AbsTolerance_Float_Int(1e-5, 1e-2).to_compare_f()), + Values( szSmall128, szVGA, sz720p, sz1080p ), + Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ), + Values( -1, CV_8U, CV_16U, CV_32F ), + Values(cv::compile_args(CORE_GPU)))); +//TODO: mask test doesn't work +#if 0 +INSTANTIATE_TEST_CASE_P(MaskPerfTestGPU, MaskPerfTest, + Combine(Values( szSmall128, szVGA, sz720p, sz1080p ), + Values( CV_8UC1, CV_16UC1, CV_16SC1), + Values(cv::compile_args(CORE_GPU)))); +#endif + +INSTANTIATE_TEST_CASE_P(MeanPerfTestGPU, MeanPerfTest, + Combine(Values( szSmall128, szVGA, sz720p, sz1080p ), + Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ), + Values(cv::compile_args(CORE_GPU)))); + +INSTANTIATE_TEST_CASE_P(Polar2CartPerfTestGPU, Polar2CartPerfTest, + Combine(Values(AbsTolerance_Float_Int(1e-5, 1e-2).to_compare_f()), + Values( szSmall128, szVGA, sz720p, sz1080p ), + Values(cv::compile_args(CORE_GPU)))); + +INSTANTIATE_TEST_CASE_P(Cart2PolarPerfTestGPU, Cart2PolarPerfTest, + Combine(Values(AbsTolerance_Float_Int(1e-2, 1e-2).to_compare_f()), + Values( szSmall128, szVGA, sz720p, sz1080p ), + Values(cv::compile_args(CORE_GPU)))); + +INSTANTIATE_TEST_CASE_P(CmpPerfTestGPU, CmpPerfTest, + Combine(Values(CMP_EQ, CMP_GE, CMP_NE, CMP_GT, CMP_LT, CMP_LE), + Values( szSmall128, szVGA, sz720p, sz1080p ), + Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ), + Values(cv::compile_args(CORE_GPU)))); + +INSTANTIATE_TEST_CASE_P(CmpWithScalarPerfTestGPU, CmpWithScalarPerfTest, + Combine(Values(CMP_EQ, CMP_GE, CMP_NE, CMP_GT, CMP_LT, CMP_LE), + Values( szSmall128, szVGA, sz720p, sz1080p ), + Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ), + Values(cv::compile_args(CORE_GPU)))); + +INSTANTIATE_TEST_CASE_P(BitwisePerfTestGPU, BitwisePerfTest, + Combine(Values(AND, OR, XOR), + Values( szSmall128, szVGA, sz720p, sz1080p ), + Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1), + Values(cv::compile_args(CORE_GPU)))); + +INSTANTIATE_TEST_CASE_P(BitwiseNotPerfTestGPU, BitwiseNotPerfTest, + Combine(Values( szSmall128, szVGA, sz720p, sz1080p ), + Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ), + Values(cv::compile_args(CORE_GPU)))); + +INSTANTIATE_TEST_CASE_P(SelectPerfTestGPU, SelectPerfTest, + Combine(Values( szSmall128, szVGA, sz720p, sz1080p ), + Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ), + Values(cv::compile_args(CORE_GPU)))); + +INSTANTIATE_TEST_CASE_P(MinPerfTestGPU, MinPerfTest, + Combine(Values( szSmall128, szVGA, sz720p, sz1080p ), + Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ), + Values(cv::compile_args(CORE_GPU)))); + +INSTANTIATE_TEST_CASE_P(MaxPerfTestGPU, MaxPerfTest, + Combine(Values( szSmall128, szVGA, sz720p, sz1080p ), + Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ), + Values(cv::compile_args(CORE_GPU)))); + +INSTANTIATE_TEST_CASE_P(AbsDiffPerfTestGPU, AbsDiffPerfTest, + Combine(Values( szSmall128, szVGA, sz720p, sz1080p ), + Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ), + Values(cv::compile_args(CORE_GPU)))); + +INSTANTIATE_TEST_CASE_P(AbsDiffCPerfTestGPU, AbsDiffCPerfTest, + Combine(Values( szSmall128, szVGA, sz720p, sz1080p ), + Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ), + Values(cv::compile_args(CORE_GPU)))); + +INSTANTIATE_TEST_CASE_P(SumPerfTestGPU, SumPerfTest, + Combine(Values( szSmall128, szVGA, sz720p, sz1080p ), + Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ), + Values(4.0), //TODO: too relaxed? + Values(cv::compile_args(CORE_GPU)))); + +// FIXME: Comparison introduced by YL doesn't work with C3 +INSTANTIATE_TEST_CASE_P(AddWeightedPerfTestGPU, AddWeightedPerfTest, + Combine(Values( szSmall128, szVGA, sz720p, sz1080p ), + Values( CV_8UC1, /*CV_8UC3,*/ CV_16UC1, CV_16SC1, CV_32FC1 ), + Values( -1, CV_8U, CV_16U, CV_32F ), + Values(0.50005), + Values(cv::compile_args(CORE_GPU)))); + +INSTANTIATE_TEST_CASE_P(NormPerfTestGPU, NormPerfTest, + Combine(Values(NORM_INF, NORM_L1, NORM_L2), + Values( szSmall128, szVGA, sz720p, sz1080p ), + Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ), + Values(4.0), //TODO: too relaxed? + Values(cv::compile_args(CORE_GPU)))); + +INSTANTIATE_TEST_CASE_P(IntegralPerfTestGPU, IntegralPerfTest, + Combine(Values( szSmall128, szVGA, sz720p, sz1080p ), + Values( CV_8UC1, CV_16UC1, CV_16SC1, CV_32FC1 ), + Values(cv::compile_args(CORE_GPU)))); + +INSTANTIATE_TEST_CASE_P(ThresholdPerfTestGPU, ThresholdPerfTest, + Combine(Values( szSmall128, szVGA, sz720p, sz1080p ), + Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ), + Values(cv::THRESH_BINARY, cv::THRESH_BINARY_INV, cv::THRESH_TRUNC, cv::THRESH_TOZERO, cv::THRESH_TOZERO_INV), + Values(cv::compile_args(CORE_GPU)))); + +INSTANTIATE_TEST_CASE_P(ThresholdPerfTestGPU, ThresholdOTPerfTest, + Combine(Values( szSmall128, szVGA, sz720p, sz1080p ), + Values( CV_8UC1 ), + Values(cv::THRESH_OTSU, cv::THRESH_TRIANGLE), + Values(cv::compile_args(CORE_GPU)))); + +INSTANTIATE_TEST_CASE_P(InRangePerfTestGPU, InRangePerfTest, + Combine(Values( szSmall128, szVGA, sz720p, sz1080p ), + Values( CV_8UC1 ), + Values(cv::compile_args(CORE_GPU)))); + +INSTANTIATE_TEST_CASE_P(Split3PerfTestGPU, Split3PerfTest, + Combine(Values( szSmall128, szVGA, sz720p, sz1080p ), + Values(cv::compile_args(CORE_GPU)))); + +INSTANTIATE_TEST_CASE_P(Split4PerfTestGPU, Split4PerfTest, + Combine(Values( szSmall128, szVGA, sz720p, sz1080p ), + Values(cv::compile_args(CORE_GPU)))); + +INSTANTIATE_TEST_CASE_P(Merge3PerfTestGPU, Merge3PerfTest, + Combine(Values( szSmall128, szVGA, sz720p, sz1080p ), + Values(cv::compile_args(CORE_GPU)))); + +INSTANTIATE_TEST_CASE_P(Merge4PerfTestGPU, Merge4PerfTest, + Combine(Values( szSmall128, szVGA, sz720p, sz1080p ), + Values(cv::compile_args(CORE_GPU)))); + +INSTANTIATE_TEST_CASE_P(RemapPerfTestGPU, RemapPerfTest, + Combine(Values( szSmall128, szVGA, sz720p, sz1080p ), + Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ), + Values(cv::compile_args(CORE_GPU)))); + +INSTANTIATE_TEST_CASE_P(FlipPerfTestGPU, FlipPerfTest, + Combine(Values( szSmall128, szVGA, sz720p, sz1080p ), + Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ), + Values(0,1,-1), + Values(cv::compile_args(CORE_GPU)))); + +INSTANTIATE_TEST_CASE_P(CropPerfTestGPU, CropPerfTest, + Combine(Values( szSmall128, szVGA, sz720p, sz1080p ), + Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ), + Values(cv::Rect(10, 8, 20, 35), cv::Rect(4, 10, 37, 50)), + Values(cv::compile_args(CORE_GPU)))); + +INSTANTIATE_TEST_CASE_P(ConcatHorPerfTestGPU, ConcatHorPerfTest, + Combine(Values( szSmall128, szVGA, sz720p, sz1080p ), + Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ), + Values(cv::compile_args(CORE_GPU)))); + +INSTANTIATE_TEST_CASE_P(ConcatVertPerfTestGPU, ConcatVertPerfTest, + Combine(Values( szSmall128, szVGA, sz720p, sz1080p ), + Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ), + Values(cv::compile_args(CORE_GPU)))); + +//TODO: fix this backend to allow ConcatVertVec ConcatHorVec +#if 0 +INSTANTIATE_TEST_CASE_P(ConcatHorVecPerfTestGPU, ConcatHorVecPerfTest, + Combine(Values(szSmall128, szVGA, sz720p, sz1080p), + Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), + Values(cv::compile_args(CORE_GPU)))); + + +INSTANTIATE_TEST_CASE_P(ConcatVertVecPerfTestGPU, ConcatVertVecPerfTest, + Combine(Values( szSmall128, szVGA, sz720p, sz1080p ), + Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ), + Values(cv::compile_args(CORE_GPU)))); +#endif + +INSTANTIATE_TEST_CASE_P(LUTPerfTestGPU, LUTPerfTest, + Combine(Values(CV_8UC1, CV_8UC3), + Values(CV_8UC1), + Values( szSmall128, szVGA, sz720p, sz1080p ), + Values(cv::compile_args(CORE_GPU)))); + +INSTANTIATE_TEST_CASE_P(LUTPerfTestCustomGPU, LUTPerfTest, + Combine(Values(CV_8UC3), + Values(CV_8UC3), + Values( szSmall128, szVGA, sz720p, sz1080p ), + Values(cv::compile_args(CORE_GPU)))); + + +INSTANTIATE_TEST_CASE_P(ConvertToPerfTestGPU, ConvertToPerfTest, + Combine(Values(CV_8UC3, CV_8UC1, CV_16UC1, CV_32FC1), + Values(CV_8U, CV_16U, CV_16S, CV_32F), + Values( szSmall128, szVGA, sz720p, sz1080p ), + Values(cv::compile_args(CORE_GPU)))); + +INSTANTIATE_TEST_CASE_P(ResizePerfTestGPU, ResizePerfTest, + Combine(Values(AbsTolerance_Float_Int(1e-3, 1e-0).to_compare_f()), //TODO: too relaxed? + Values(CV_8UC1, CV_16UC1, CV_16SC1), + Values(cv::INTER_NEAREST, cv::INTER_LINEAR, cv::INTER_AREA), + Values( szSmall128, szVGA, sz720p, sz1080p ), + Values(cv::Size(64,64), + cv::Size(30,30)), + Values(cv::compile_args(CORE_GPU)))); + +INSTANTIATE_TEST_CASE_P(ResizeFxFyPerfTestGPU, ResizeFxFyPerfTest, + Combine(Values(AbsTolerance_Float_Int(1e-1, 1e-0).to_compare_f()), //TODO: too relaxed? + Values(CV_8UC1, CV_16UC1, CV_16SC1), + Values(cv::INTER_NEAREST, cv::INTER_LINEAR, cv::INTER_AREA), + Values( szSmall128, szVGA, sz720p, sz1080p ), + Values(0.5, 0.1), + Values(0.5, 0.1), + Values(cv::compile_args(CORE_GPU)))); +} diff --git a/modules/gapi/perf/gpu/gapi_imgproc_perf_tests_gpu.cpp b/modules/gapi/perf/gpu/gapi_imgproc_perf_tests_gpu.cpp new file mode 100644 index 0000000000..7abe84d4b8 --- /dev/null +++ b/modules/gapi/perf/gpu/gapi_imgproc_perf_tests_gpu.cpp @@ -0,0 +1,180 @@ +// This file is part of OpenCV project. +// It is subject to the license terms in the LICENSE file found in the top-level directory +// of this distribution and at http://opencv.org/license.html. +// +// Copyright (C) 2018 Intel Corporation + + +#include "../perf_precomp.hpp" +#include "../common/gapi_imgproc_perf_tests.hpp" +#include "opencv2/gapi/gpu/imgproc.hpp" + +#define IMGPROC_GPU cv::gapi::imgproc::gpu::kernels() + +namespace opencv_test +{ + + +INSTANTIATE_TEST_CASE_P(SepFilterPerfTestGPU_8U, SepFilterPerfTest, + Combine(Values(AbsToleranceSepFilter(1e-4f).to_compare_f()), + Values(CV_8UC1, CV_8UC3), + Values(3), + Values(szVGA, sz720p, sz1080p), + Values(-1, CV_16S, CV_32F), + Values(cv::compile_args(IMGPROC_GPU)))); + +INSTANTIATE_TEST_CASE_P(SepFilterPerfTestGPU_other, SepFilterPerfTest, + Combine(Values(AbsToleranceSepFilter(1e-4f).to_compare_f()), + Values(CV_16UC1, CV_16SC1, CV_32FC1), + Values(3), + Values(szVGA, sz720p, sz1080p), + Values(-1, CV_32F), + Values(cv::compile_args(IMGPROC_GPU)))); + + + +INSTANTIATE_TEST_CASE_P(Filter2DPerfTestGPU, Filter2DPerfTest, + Combine(Values(AbsTolerance_Float_Int(1e-5, 1e-3).to_compare_f()), + Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), + Values(3, 4, 5, 7), + Values(szVGA, sz720p, sz1080p), + Values(cv::BORDER_DEFAULT), + Values(-1, CV_32F), + Values(cv::compile_args(IMGPROC_GPU)))); + +INSTANTIATE_TEST_CASE_P(BoxFilterPerfTestGPU, BoxFilterPerfTest, + Combine(Values(AbsTolerance_Float_Int(1e-5, 1e-3).to_compare_f()), + Values(/*CV_8UC1,*/ CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), + Values(3,5), + Values(szVGA, sz720p, sz1080p), + Values(cv::BORDER_DEFAULT), + Values(-1, CV_32F), + Values(cv::compile_args(IMGPROC_GPU)))); //TODO: 8UC1 doesn't work + +INSTANTIATE_TEST_CASE_P(BlurPerfTestGPU, BlurPerfTest, + Combine(Values(AbsTolerance_Float_Int(1e-4, 1e-2).to_compare_f()), + Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), + Values(3, 5), + Values(szVGA, sz720p, sz1080p), + Values(cv::BORDER_DEFAULT), + Values(cv::compile_args(IMGPROC_GPU)))); + +INSTANTIATE_TEST_CASE_P(GaussianBlurPerfTestGPU, GaussianBlurPerfTest, + Combine(Values(AbsToleranceGaussianBlur_Float_Int(1e-5, 0.05).to_compare_f()), //TODO: too relaxed? + Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), + Values(3, 5), + Values(szVGA, sz720p, sz1080p), + Values(cv::compile_args(IMGPROC_GPU)))); + +INSTANTIATE_TEST_CASE_P(MedianBlurPerfTestGPU, MedianBlurPerfTest, + Combine(Values(AbsExact().to_compare_f()), + Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), + Values(3, 5), + Values(szVGA, sz720p, sz1080p), + Values(cv::compile_args(IMGPROC_GPU)))); + +INSTANTIATE_TEST_CASE_P(ErodePerfTestGPU, ErodePerfTest, + Combine(Values(AbsExact().to_compare_f()), + Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), + Values(3, 5), + Values(szVGA, sz720p, sz1080p), + Values(cv::MorphShapes::MORPH_RECT, + cv::MorphShapes::MORPH_CROSS, + cv::MorphShapes::MORPH_ELLIPSE), + Values(cv::compile_args(IMGPROC_GPU)))); + +INSTANTIATE_TEST_CASE_P(Erode3x3PerfTestGPU, Erode3x3PerfTest, + Combine(Values(AbsExact().to_compare_f()), + Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), + Values(szVGA, sz720p, sz1080p), + Values(1,2,4), + Values(cv::compile_args(IMGPROC_GPU)))); + +INSTANTIATE_TEST_CASE_P(DilatePerfTestGPU, DilatePerfTest, + Combine(Values(AbsExact().to_compare_f()), + Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), + Values(3, 5), + Values(szVGA, sz720p, sz1080p), + Values(cv::MorphShapes::MORPH_RECT, + cv::MorphShapes::MORPH_CROSS, + cv::MorphShapes::MORPH_ELLIPSE), + Values(cv::compile_args(IMGPROC_GPU)))); + +INSTANTIATE_TEST_CASE_P(Dilate3x3PerfTestGPU, Dilate3x3PerfTest, + Combine(Values(AbsExact().to_compare_f()), + Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), + Values(szVGA, sz720p, sz1080p), + Values(1,2,4), + Values(cv::compile_args(IMGPROC_GPU)))); + +INSTANTIATE_TEST_CASE_P(SobelPerfTestGPU, SobelPerfTest, + Combine(Values(AbsTolerance_Float_Int(1e-4, 1e-4).to_compare_f()), + Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1/*, CV_32FC1*/), //TODO: CV_32FC1 fails accuracy + Values(3, 5), + Values(szVGA, sz720p, sz1080p), + Values(-1, CV_32F), + Values(0, 1), + Values(1, 2), + Values(cv::compile_args(IMGPROC_GPU)))); + +INSTANTIATE_TEST_CASE_P(CannyPerfTestGPU, CannyPerfTest, + Combine(Values(AbsTolerance_Float_Int(1e-4, 1e-2).to_compare_f()), + Values(CV_8UC1, CV_8UC3), + Values(szVGA, sz720p, sz1080p), + Values(3.0, 120.0), + Values(125.0, 240.0), + Values(3, 5), + Values(true, false), + Values(cv::compile_args(IMGPROC_GPU)))); + +INSTANTIATE_TEST_CASE_P(EqHistPerfTestGPU, EqHistPerfTest, + Combine(Values(AbsExact().to_compare_f()), + Values(szVGA, sz720p, sz1080p), + Values(cv::compile_args(IMGPROC_GPU)))); + +INSTANTIATE_TEST_CASE_P(RGB2GrayPerfTestGPU, RGB2GrayPerfTest, + Combine(Values(AbsExact().to_compare_f()), + Values(szVGA, sz720p, sz1080p), + Values(cv::compile_args(IMGPROC_GPU)))); + +INSTANTIATE_TEST_CASE_P(BGR2GrayPerfTestGPU, BGR2GrayPerfTest, + Combine(Values(AbsExact().to_compare_f()), + Values(szVGA, sz720p, sz1080p), + Values(cv::compile_args(IMGPROC_GPU)))); + +INSTANTIATE_TEST_CASE_P(RGB2YUVPerfTestGPU, RGB2YUVPerfTest, + Combine(Values(AbsExact().to_compare_f()), + Values(szVGA, sz720p, sz1080p), + Values(cv::compile_args(IMGPROC_GPU)))); + +INSTANTIATE_TEST_CASE_P(YUV2RGBPerfTestGPU, YUV2RGBPerfTest, + Combine(Values(AbsExact().to_compare_f()), + Values(szVGA, sz720p, sz1080p), + Values(cv::compile_args(IMGPROC_GPU)))); + +INSTANTIATE_TEST_CASE_P(RGB2LabPerfTestGPU, RGB2LabPerfTest, + Combine(Values(AbsExact().to_compare_f()), + Values(szVGA, sz720p, sz1080p), + Values(cv::compile_args(IMGPROC_GPU)))); + +INSTANTIATE_TEST_CASE_P(BGR2LUVPerfTestGPU, BGR2LUVPerfTest, + Combine(Values(ToleranceTriple(0.25 * 3, 0.01 * 3, 0.0001 * 3).to_compare_f()), + Values(szVGA, sz720p, sz1080p), + Values(cv::compile_args(IMGPROC_GPU)))); + +INSTANTIATE_TEST_CASE_P(LUV2BGRPerfTestGPU, LUV2BGRPerfTest, + Combine(Values(AbsExact().to_compare_f()), + Values(szVGA, sz720p, sz1080p), + Values(cv::compile_args(IMGPROC_GPU)))); + +INSTANTIATE_TEST_CASE_P(BGR2YUVPerfTestGPU, BGR2YUVPerfTest, + Combine(Values(AbsExact().to_compare_f()), + Values(szVGA, sz720p, sz1080p), + Values(cv::compile_args(IMGPROC_GPU)))); + +INSTANTIATE_TEST_CASE_P(YUV2BGRPerfTestGPU, YUV2BGRPerfTest, + Combine(Values(AbsExact().to_compare_f()), + Values(szVGA, sz720p, sz1080p), + Values(cv::compile_args(IMGPROC_GPU)))); + +} diff --git a/modules/gapi/perf/perf_precomp.hpp b/modules/gapi/perf/perf_precomp.hpp index c7e79ba2f4..7b50d6bd7e 100644 --- a/modules/gapi/perf/perf_precomp.hpp +++ b/modules/gapi/perf/perf_precomp.hpp @@ -16,6 +16,7 @@ #include "opencv2/gapi/imgproc.hpp" #include "opencv2/gapi/core.hpp" #include "opencv2/gapi/cpu/gcpukernel.hpp" +#include "opencv2/gapi/gpu/ggpukernel.hpp" #include "opencv2/gapi/operators.hpp" #endif diff --git a/modules/gapi/src/api/gbackend.cpp b/modules/gapi/src/api/gbackend.cpp index 095e76f53d..8df8b36f16 100644 --- a/modules/gapi/src/api/gbackend.cpp +++ b/modules/gapi/src/api/gbackend.cpp @@ -83,20 +83,41 @@ namespace magazine { // FIXME implement the below functions with visit()? -void bindInArg(Mag& mag, const RcDesc &rc, const GRunArg &arg) +void bindInArg(Mag& mag, const RcDesc &rc, const GRunArg &arg, bool is_umat) { switch (rc.shape) { case GShape::GMAT: { - auto& mag_mat = mag.template slot()[rc.id]; switch (arg.index()) { - case GRunArg::index_of() : mag_mat = util::get(arg); break; + case GRunArg::index_of() : + if (is_umat) + { + auto& mag_umat = mag.template slot()[rc.id]; + mag_umat = to_ocv(util::get(arg)).getUMat(ACCESS_READ); + } + else + { + auto& mag_mat = mag.template slot()[rc.id]; + mag_mat = util::get(arg); + } + break; #if !defined(GAPI_STANDALONE) - case GRunArg::index_of() : mag_mat = to_own(util::get(arg)); break; + case GRunArg::index_of() : + if (is_umat) + { + auto& mag_umat = mag.template slot()[rc.id]; + mag_umat = (util::get(arg)); + } + else + { + auto& mag_mat = mag.template slot()[rc.id]; + mag_mat = to_own(util::get(arg)); + } + break; #endif // !defined(GAPI_STANDALONE) - default: util::throw_error(std::logic_error("content type of the runtime argument does not match to resource description ?")); + default: util::throw_error(std::logic_error("content type of the runtime argument does not match to resource description ?")); } break; } @@ -125,20 +146,41 @@ void bindInArg(Mag& mag, const RcDesc &rc, const GRunArg &arg) } } -void bindOutArg(Mag& mag, const RcDesc &rc, const GRunArgP &arg) +void bindOutArg(Mag& mag, const RcDesc &rc, const GRunArgP &arg, bool is_umat) { switch (rc.shape) { case GShape::GMAT: { - auto& mag_mat = mag.template slot()[rc.id]; switch (arg.index()) { - case GRunArgP::index_of() : mag_mat = * util::get(arg); break; + case GRunArgP::index_of() : + if (is_umat) + { + auto& mag_umat = mag.template slot()[rc.id]; + mag_umat = to_ocv(*(util::get(arg))).getUMat(ACCESS_RW); + } + else + { + auto& mag_mat = mag.template slot()[rc.id]; + mag_mat = *util::get(arg); + } + break; #if !defined(GAPI_STANDALONE) - case GRunArgP::index_of() : mag_mat = to_own(* util::get(arg)); break; + case GRunArgP::index_of() : + if (is_umat) + { + auto& mag_umat = mag.template slot()[rc.id]; + mag_umat = (*util::get(arg)); + } + else + { + auto& mag_mat = mag.template slot()[rc.id]; + mag_mat = to_own(*util::get(arg)); + } + break; #endif // !defined(GAPI_STANDALONE) - default: util::throw_error(std::logic_error("content type of the runtime argument does not match to resource description ?")); + default: util::throw_error(std::logic_error("content type of the runtime argument does not match to resource description ?")); } break; } @@ -208,11 +250,15 @@ cv::GRunArg getArg(const Mag& mag, const RcDesc &ref) } } -cv::GRunArgP getObjPtr(Mag& mag, const RcDesc &rc) +cv::GRunArgP getObjPtr(Mag& mag, const RcDesc &rc, bool is_umat) { switch (rc.shape) { - case GShape::GMAT: return GRunArgP(&mag.template slot() [rc.id]); + case GShape::GMAT: + if (is_umat) + return GRunArgP(&mag.template slot()[rc.id]); + else + return GRunArgP(&mag.template slot()[rc.id]); case GShape::GSCALAR: return GRunArgP(&mag.template slot()[rc.id]); // Note: .at() is intentional for GArray as object MUST be already there // (and constructer by either bindIn/Out or resetInternal) @@ -230,7 +276,7 @@ cv::GRunArgP getObjPtr(Mag& mag, const RcDesc &rc) } } -void writeBack(const Mag& mag, const RcDesc &rc, GRunArgP &g_arg) +void writeBack(const Mag& mag, const RcDesc &rc, GRunArgP &g_arg, bool is_umat) { switch (rc.shape) { @@ -248,12 +294,20 @@ void writeBack(const Mag& mag, const RcDesc &rc, GRunArgP &g_arg) case GRunArgP::index_of() : out_arg_data = util::get(g_arg)->data; break; #if !defined(GAPI_STANDALONE) case GRunArgP::index_of() : out_arg_data = util::get(g_arg)->data; break; + case GRunArgP::index_of() : out_arg_data = (util::get(g_arg))->getMat(ACCESS_RW).data; break; #endif // !defined(GAPI_STANDALONE) default: util::throw_error(std::logic_error("content type of the runtime argument does not match to resource description ?")); } - - auto& in_mag = mag.template slot().at(rc.id); - GAPI_Assert((out_arg_data == in_mag.data) && " data for output parameters was reallocated ?"); + if (is_umat) + { + auto& in_mag = mag.template slot().at(rc.id); + GAPI_Assert((out_arg_data == (in_mag.getMat(ACCESS_RW).data)) && " data for output parameters was reallocated ?"); + } + else + { + auto& in_mag = mag.template slot().at(rc.id); + GAPI_Assert((out_arg_data == in_mag.data) && " data for output parameters was reallocated ?"); + } break; } diff --git a/modules/gapi/src/api/gmat.cpp b/modules/gapi/src/api/gmat.cpp index 3dd8277905..e8c528555f 100644 --- a/modules/gapi/src/api/gmat.cpp +++ b/modules/gapi/src/api/gmat.cpp @@ -38,6 +38,10 @@ cv::GMatDesc cv::descr_of(const cv::Mat &mat) { return GMatDesc{mat.depth(), mat.channels(), {mat.cols, mat.rows}}; } +cv::GMatDesc cv::descr_of(const cv::UMat &mat) +{ + return GMatDesc{ mat.depth(), mat.channels(),{ mat.cols, mat.rows } }; +} #endif cv::GMatDesc cv::gapi::own::descr_of(const cv::gapi::own::Mat &mat) diff --git a/modules/gapi/src/api/gproto.cpp b/modules/gapi/src/api/gproto.cpp index 6f6fad407b..2482d628b4 100644 --- a/modules/gapi/src/api/gproto.cpp +++ b/modules/gapi/src/api/gproto.cpp @@ -122,6 +122,7 @@ cv::GMetaArg cv::descr_of(const cv::GRunArgP &argp) { #if !defined(GAPI_STANDALONE) case GRunArgP::index_of(): return GMetaArg(descr_of(*util::get(argp))); + case GRunArgP::index_of(): return GMetaArg(descr_of(*util::get(argp))); case GRunArgP::index_of(): return GMetaArg(descr_of(*util::get(argp))); #endif // !defined(GAPI_STANDALONE) case GRunArgP::index_of(): return GMetaArg(descr_of(*util::get(argp))); diff --git a/modules/gapi/src/backends/common/gbackend.hpp b/modules/gapi/src/backends/common/gbackend.hpp index 82dcf344b2..613022cb9c 100644 --- a/modules/gapi/src/backends/common/gbackend.hpp +++ b/modules/gapi/src/backends/common/gbackend.hpp @@ -45,18 +45,21 @@ namespace magazine { }; } // namespace magazine - +#if !defined(GAPI_STANDALONE) +using Mag = magazine::Class; +#else using Mag = magazine::Class; +#endif namespace magazine { - void bindInArg (Mag& mag, const RcDesc &rc, const GRunArg &arg); - void bindOutArg(Mag& mag, const RcDesc &rc, const GRunArgP &arg); + void bindInArg (Mag& mag, const RcDesc &rc, const GRunArg &arg, bool is_umat = false); + void bindOutArg(Mag& mag, const RcDesc &rc, const GRunArgP &arg, bool is_umat = false); void resetInternalData(Mag& mag, const Data &d); cv::GRunArg getArg (const Mag& mag, const RcDesc &ref); - cv::GRunArgP getObjPtr ( Mag& mag, const RcDesc &rc); - void writeBack (const Mag& mag, const RcDesc &rc, GRunArgP &g_arg); + cv::GRunArgP getObjPtr ( Mag& mag, const RcDesc &rc, bool is_umat = false); + void writeBack (const Mag& mag, const RcDesc &rc, GRunArgP &g_arg, bool is_umat = false); } // namespace magazine namespace detail diff --git a/modules/gapi/src/backends/gpu/ggpubackend.cpp b/modules/gapi/src/backends/gpu/ggpubackend.cpp new file mode 100644 index 0000000000..eda6a5fd78 --- /dev/null +++ b/modules/gapi/src/backends/gpu/ggpubackend.cpp @@ -0,0 +1,226 @@ +// This file is part of OpenCV project. +// It is subject to the license terms in the LICENSE file found in the top-level directory +// of this distribution and at http://opencv.org/license.html. +// +// Copyright (C) 2018 Intel Corporation + + +#include "precomp.hpp" + +#include +#include + +#include + +#include +#include +#include + +#include + +#include "opencv2/gapi/gcommon.hpp" +#include "opencv2/gapi/util/any.hpp" +#include "opencv2/gapi/gtype_traits.hpp" + +#include "compiler/gobjref.hpp" +#include "compiler/gmodel.hpp" + +#include "backends/gpu/ggpubackend.hpp" +#include "backends/gpu/ggpuimgproc.hpp" +#include "backends/gpu/ggpucore.hpp" + +#include "api/gbackend_priv.hpp" // FIXME: Make it part of Backend SDK! + +// FIXME: Is there a way to take a typed graph (our GModel), +// and create a new typed graph _ATOP_ of that (by extending with a couple of +// new types?). +// Alternatively, is there a way to compose types graphs? +// +// If not, we need to introduce that! +using GGPUModel = ade::TypedGraph + < cv::gimpl::Unit + , cv::gimpl::Protocol + >; + +// FIXME: Same issue with Typed and ConstTyped +using GConstGGPUModel = ade::ConstTypedGraph + < cv::gimpl::Unit + , cv::gimpl::Protocol + >; + +namespace +{ + class GGPUBackendImpl final: public cv::gapi::GBackend::Priv + { + virtual void unpackKernel(ade::Graph &graph, + const ade::NodeHandle &op_node, + const cv::GKernelImpl &impl) override + { + GGPUModel gm(graph); + auto gpu_impl = cv::util::any_cast(impl.opaque); + gm.metadata(op_node).set(cv::gimpl::Unit{gpu_impl}); + } + + virtual EPtr compile(const ade::Graph &graph, + const cv::GCompileArgs &, + const std::vector &nodes) const override + { + return EPtr{new cv::gimpl::GGPUExecutable(graph, nodes)}; + } + }; +} + +cv::gapi::GBackend cv::gapi::gpu::backend() +{ + static cv::gapi::GBackend this_backend(std::make_shared()); + return this_backend; +} + +// GGPUExcecutable implementation ////////////////////////////////////////////// +cv::gimpl::GGPUExecutable::GGPUExecutable(const ade::Graph &g, + const std::vector &nodes) + : m_g(g), m_gm(m_g) +{ + // Convert list of operations (which is topologically sorted already) + // into an execution script. + for (auto &nh : nodes) + { + switch (m_gm.metadata(nh).get().t) + { + case NodeType::OP: m_script.push_back({nh, GModel::collectOutputMeta(m_gm, nh)}); break; + case NodeType::DATA: + { + m_dataNodes.push_back(nh); + const auto &desc = m_gm.metadata(nh).get(); + if (desc.storage == Data::Storage::CONST) + { + auto rc = RcDesc{desc.rc, desc.shape, desc.ctor}; + magazine::bindInArg(m_res, rc, m_gm.metadata(nh).get().arg); + } + //preallocate internal Mats in advance + if (desc.storage == Data::Storage::INTERNAL && desc.shape == GShape::GMAT) + { + const auto mat_desc = util::get(desc.meta); + const auto type = CV_MAKETYPE(mat_desc.depth, mat_desc.chan); + m_res.slot()[desc.rc].create(mat_desc.size.width, mat_desc.size.height, type); + } + break; + } + default: util::throw_error(std::logic_error("Unsupported NodeType type")); + } + } +} + +// FIXME: Document what it does +cv::GArg cv::gimpl::GGPUExecutable::packArg(const GArg &arg) +{ + // No API placeholders allowed at this point + // FIXME: this check has to be done somewhere in compilation stage. + GAPI_Assert( arg.kind != cv::detail::ArgKind::GMAT + && arg.kind != cv::detail::ArgKind::GSCALAR + && arg.kind != cv::detail::ArgKind::GARRAY); + + if (arg.kind != cv::detail::ArgKind::GOBJREF) + { + // All other cases - pass as-is, with no transformations to GArg contents. + return arg; + } + GAPI_Assert(arg.kind == cv::detail::ArgKind::GOBJREF); + + // Wrap associated CPU object (either host or an internal one) + // FIXME: object can be moved out!!! GExecutor faced that. + const cv::gimpl::RcDesc &ref = arg.get(); + switch (ref.shape) + { + case GShape::GMAT: return GArg(m_res.slot()[ref.id]); + case GShape::GSCALAR: return GArg(m_res.slot()[ref.id]); + // Note: .at() is intentional for GArray as object MUST be already there + // (and constructed by either bindIn/Out or resetInternal) + case GShape::GARRAY: return GArg(m_res.slot().at(ref.id)); + default: + util::throw_error(std::logic_error("Unsupported GShape type")); + break; + } +} + +void cv::gimpl::GGPUExecutable::run(std::vector &&input_objs, + std::vector &&output_objs) +{ + // Update resources with run-time information - what this Island + // has received from user (or from another Island, or mix...) + // FIXME: Check input/output objects against GIsland protocol + + for (auto& it : input_objs) magazine::bindInArg (m_res, it.first, it.second, true); + for (auto& it : output_objs) magazine::bindOutArg(m_res, it.first, it.second, true); + + // Initialize (reset) internal data nodes with user structures + // before processing a frame (no need to do it for external data structures) + GModel::ConstGraph gm(m_g); + for (auto nh : m_dataNodes) + { + const auto &desc = gm.metadata(nh).get(); + + if ( desc.storage == Data::Storage::INTERNAL + && !util::holds_alternative(desc.ctor)) + { + // FIXME: Note that compile-time constant data objects (like + // a value-initialized GArray) also satisfy this condition + // and should be excluded, but now we just don't support it + magazine::resetInternalData(m_res, desc); + } + } + + // OpenCV backend execution is not a rocket science at all. + // Simply invoke our kernels in the proper order. + GConstGGPUModel gcm(m_g); + for (auto &op_info : m_script) + { + const auto &op = m_gm.metadata(op_info.nh).get(); + + // Obtain our real execution unit + // TODO: Should kernels be copyable? + GGPUKernel k = gcm.metadata(op_info.nh).get().k; + + // Initialize kernel's execution context: + // - Input parameters + GGPUContext context; + context.m_args.reserve(op.args.size()); + + using namespace std::placeholders; + ade::util::transform(op.args, + std::back_inserter(context.m_args), + std::bind(&GGPUExecutable::packArg, this, _1)); + + // - Output parameters. + // FIXME: pre-allocate internal Mats, etc, according to the known meta + for (const auto &out_it : ade::util::indexed(op.outs)) + { + // FIXME: Can the same GArg type resolution mechanism be reused here? + const auto out_port = ade::util::index(out_it); + const auto out_desc = ade::util::value(out_it); + context.m_results[out_port] = magazine::getObjPtr(m_res, out_desc, true); + } + + // Now trigger the executable unit + k.apply(context); + + for (const auto &out_it : ade::util::indexed(op_info.expected_out_metas)) + { + const auto out_index = ade::util::index(out_it); + const auto expected_meta = ade::util::value(out_it); + const auto out_meta = descr_of(context.m_results[out_index]); + + if (expected_meta != out_meta) + { + util::throw_error + (std::logic_error + ("Output meta doesn't " + "coincide with the generated meta\n" + "Expected: " + ade::util::to_string(expected_meta) + "\n" + "Actual : " + ade::util::to_string(out_meta))); + } + } + } // for(m_script) + + for (auto &it : output_objs) magazine::writeBack(m_res, it.first, it.second, true); +} diff --git a/modules/gapi/src/backends/gpu/ggpubackend.hpp b/modules/gapi/src/backends/gpu/ggpubackend.hpp new file mode 100644 index 0000000000..1fb128d5f7 --- /dev/null +++ b/modules/gapi/src/backends/gpu/ggpubackend.hpp @@ -0,0 +1,72 @@ +// This file is part of OpenCV project. +// It is subject to the license terms in the LICENSE file found in the top-level directory +// of this distribution and at http://opencv.org/license.html. +// +// Copyright (C) 2018 Intel Corporation + + +#ifndef OPENCV_GAPI_GGPUBACKEND_HPP +#define OPENCV_GAPI_GGPUBACKEND_HPP + +#include // map +#include // unordered_map +#include // tuple +#include // type_list_index + +#include "opencv2/gapi/garg.hpp" +#include "opencv2/gapi/gproto.hpp" +#include "opencv2/gapi/gpu/ggpukernel.hpp" + + +#include "api/gapi_priv.hpp" +#include "backends/common/gbackend.hpp" +#include "compiler/gislandmodel.hpp" + +namespace cv { namespace gimpl { + +struct Unit +{ + static const char *name() { return "GPUKernel"; } + GGPUKernel k; +}; + +class GGPUExecutable final: public GIslandExecutable +{ + const ade::Graph &m_g; + GModel::ConstGraph m_gm; + + struct OperationInfo + { + ade::NodeHandle nh; + GMetaArgs expected_out_metas; + }; + + // Execution script, currently absolutely naive + std::vector m_script; + // List of all resources in graph (both internal and external) + std::vector m_dataNodes; + + // Actual data of all resources in graph (both internal and external) + Mag m_res; + GArg packArg(const GArg &arg); + +public: + GGPUExecutable(const ade::Graph &graph, + const std::vector &nodes); + + virtual inline bool canReshape() const override { return false; } + virtual inline void reshape(ade::Graph&, const GCompileArgs&) override + { + // FIXME: GPU plugin is in fact reshapeable (as it was initially, + // even before outMeta() has been introduced), so this limitation + // should be dropped. + util::throw_error(std::logic_error("GGPUExecutable::reshape() should never be called")); + } + + virtual void run(std::vector &&input_objs, + std::vector &&output_objs) override; +}; + +}} + +#endif // OPENCV_GAPI_GGPUBACKEND_HPP diff --git a/modules/gapi/src/backends/gpu/ggpucore.cpp b/modules/gapi/src/backends/gpu/ggpucore.cpp new file mode 100644 index 0000000000..a1ee6a1133 --- /dev/null +++ b/modules/gapi/src/backends/gpu/ggpucore.cpp @@ -0,0 +1,582 @@ +// This file is part of OpenCV project. +// It is subject to the license terms in the LICENSE file found in the top-level directory +// of this distribution and at http://opencv.org/license.html. +// +// Copyright (C) 2018 Intel Corporation + + +#include "precomp.hpp" + +#include "opencv2/gapi/core.hpp" +#include "opencv2/gapi/gpu/core.hpp" +#include "backends/gpu/ggpucore.hpp" + +GAPI_GPU_KERNEL(GGPUAdd, cv::gapi::core::GAdd) +{ + static void run(const cv::UMat& a, const cv::UMat& b, int dtype, cv::UMat& out) + { + cv::add(a, b, out, cv::noArray(), dtype); + } +}; + +GAPI_GPU_KERNEL(GGPUAddC, cv::gapi::core::GAddC) +{ + static void run(const cv::UMat& a, const cv::Scalar& b, int dtype, cv::UMat& out) + { + cv::add(a, b, out, cv::noArray(), dtype); + } +}; + +GAPI_GPU_KERNEL(GGPUSub, cv::gapi::core::GSub) +{ + static void run(const cv::UMat& a, const cv::UMat& b, int dtype, cv::UMat& out) + { + cv::subtract(a, b, out, cv::noArray(), dtype); + } +}; + +GAPI_GPU_KERNEL(GGPUSubC, cv::gapi::core::GSubC) +{ + static void run(const cv::UMat& a, const cv::Scalar& b, int dtype, cv::UMat& out) + { + cv::subtract(a, b, out, cv::noArray(), dtype); + } +}; + +GAPI_GPU_KERNEL(GGPUSubRC, cv::gapi::core::GSubRC) +{ + static void run(const cv::Scalar& a, const cv::UMat& b, int dtype, cv::UMat& out) + { + cv::subtract(a, b, out, cv::noArray(), dtype); + } +}; + +GAPI_GPU_KERNEL(GGPUMul, cv::gapi::core::GMul) +{ + static void run(const cv::UMat& a, const cv::UMat& b, double scale, int dtype, cv::UMat& out) + { + cv::multiply(a, b, out, scale, dtype); + } +}; + +GAPI_GPU_KERNEL(GGPUMulCOld, cv::gapi::core::GMulCOld) +{ + static void run(const cv::UMat& a, double b, int dtype, cv::UMat& out) + { + cv::multiply(a, b, out, 1, dtype); + } +}; + +GAPI_GPU_KERNEL(GGPUMulC, cv::gapi::core::GMulC) +{ + static void run(const cv::UMat& a, const cv::Scalar& b, int dtype, cv::UMat& out) + { + cv::multiply(a, b, out, 1, dtype); + } +}; + +GAPI_GPU_KERNEL(GGPUDiv, cv::gapi::core::GDiv) +{ + static void run(const cv::UMat& a, const cv::UMat& b, double scale, int dtype, cv::UMat& out) + { + cv::divide(a, b, out, scale, dtype); + } +}; + +GAPI_GPU_KERNEL(GGPUDivC, cv::gapi::core::GDivC) +{ + static void run(const cv::UMat& a, const cv::Scalar& b, double scale, int dtype, cv::UMat& out) + { + cv::divide(a, b, out, scale, dtype); + } +}; + +GAPI_GPU_KERNEL(GGPUDivRC, cv::gapi::core::GDivRC) +{ + static void run(const cv::Scalar& a, const cv::UMat& b, double scale, int dtype, cv::UMat& out) + { + cv::divide(a, b, out, scale, dtype); + } +}; + +GAPI_GPU_KERNEL(GGPUMask, cv::gapi::core::GMask) +{ + static void run(const cv::UMat& in, const cv::UMat& mask, cv::UMat& out) + { + out = cv::UMat::zeros(in.size(), in.type()); + in.copyTo(out, mask); + } +}; + + +GAPI_GPU_KERNEL(GGPUMean, cv::gapi::core::GMean) +{ + static void run(const cv::UMat& in, cv::Scalar& out) + { + out = cv::mean(in); + } +}; + +GAPI_GPU_KERNEL(GGPUPolarToCart, cv::gapi::core::GPolarToCart) +{ + static void run(const cv::UMat& magn, const cv::UMat& angle, bool angleInDegrees, cv::UMat& outx, cv::UMat& outy) + { + cv::polarToCart(magn, angle, outx, outy, angleInDegrees); + } +}; + +GAPI_GPU_KERNEL(GGPUCartToPolar, cv::gapi::core::GCartToPolar) +{ + static void run(const cv::UMat& x, const cv::UMat& y, bool angleInDegrees, cv::UMat& outmagn, cv::UMat& outangle) + { + cv::cartToPolar(x, y, outmagn, outangle, angleInDegrees); + } +}; + +GAPI_GPU_KERNEL(GGPUCmpGT, cv::gapi::core::GCmpGT) +{ + static void run(const cv::UMat& a, const cv::UMat& b, cv::UMat& out) + { + cv::compare(a, b, out, cv::CMP_GT); + } +}; + +GAPI_GPU_KERNEL(GGPUCmpGE, cv::gapi::core::GCmpGE) +{ + static void run(const cv::UMat& a, const cv::UMat& b, cv::UMat& out) + { + cv::compare(a, b, out, cv::CMP_GE); + } +}; + +GAPI_GPU_KERNEL(GGPUCmpLE, cv::gapi::core::GCmpLE) +{ + static void run(const cv::UMat& a, const cv::UMat& b, cv::UMat& out) + { + cv::compare(a, b, out, cv::CMP_LE); + } +}; + +GAPI_GPU_KERNEL(GGPUCmpLT, cv::gapi::core::GCmpLT) +{ + static void run(const cv::UMat& a, const cv::UMat& b, cv::UMat& out) + { + cv::compare(a, b, out, cv::CMP_LT); + } +}; + +GAPI_GPU_KERNEL(GGPUCmpEQ, cv::gapi::core::GCmpEQ) +{ + static void run(const cv::UMat& a, const cv::UMat& b, cv::UMat& out) + { + cv::compare(a, b, out, cv::CMP_EQ); + } +}; + +GAPI_GPU_KERNEL(GGPUCmpNE, cv::gapi::core::GCmpNE) +{ + static void run(const cv::UMat& a, const cv::UMat& b, cv::UMat& out) + { + cv::compare(a, b, out, cv::CMP_NE); + } +}; + +GAPI_GPU_KERNEL(GGPUCmpGTScalar, cv::gapi::core::GCmpGTScalar) +{ + static void run(const cv::UMat& a, const cv::Scalar& b, cv::UMat& out) + { + cv::compare(a, b, out, cv::CMP_GT); + } +}; + +GAPI_GPU_KERNEL(GGPUCmpGEScalar, cv::gapi::core::GCmpGEScalar) +{ + static void run(const cv::UMat& a, const cv::Scalar& b, cv::UMat& out) + { + cv::compare(a, b, out, cv::CMP_GE); + } +}; + +GAPI_GPU_KERNEL(GGPUCmpLEScalar, cv::gapi::core::GCmpLEScalar) +{ + static void run(const cv::UMat& a, const cv::Scalar& b, cv::UMat& out) + { + cv::compare(a, b, out, cv::CMP_LE); + } +}; + +GAPI_GPU_KERNEL(GGPUCmpLTScalar, cv::gapi::core::GCmpLTScalar) +{ + static void run(const cv::UMat& a, const cv::Scalar& b, cv::UMat& out) + { + cv::compare(a, b, out, cv::CMP_LT); + } +}; + +GAPI_GPU_KERNEL(GGPUCmpEQScalar, cv::gapi::core::GCmpEQScalar) +{ + static void run(const cv::UMat& a, const cv::Scalar& b, cv::UMat& out) + { + cv::compare(a, b, out, cv::CMP_EQ); + } +}; + +GAPI_GPU_KERNEL(GGPUCmpNEScalar, cv::gapi::core::GCmpNEScalar) +{ + static void run(const cv::UMat& a, const cv::Scalar& b, cv::UMat& out) + { + cv::compare(a, b, out, cv::CMP_NE); + } +}; + +GAPI_GPU_KERNEL(GGPUAnd, cv::gapi::core::GAnd) +{ + static void run(const cv::UMat& a, const cv::UMat& b, cv::UMat& out) + { + cv::bitwise_and(a, b, out); + } +}; + +GAPI_GPU_KERNEL(GGPUAndS, cv::gapi::core::GAndS) +{ + static void run(const cv::UMat& a, const cv::Scalar& b, cv::UMat& out) + { + cv::bitwise_and(a, b, out); + } +}; + +GAPI_GPU_KERNEL(GGPUOr, cv::gapi::core::GOr) +{ + static void run(const cv::UMat& a, const cv::UMat& b, cv::UMat& out) + { + cv::bitwise_or(a, b, out); + } +}; + +GAPI_GPU_KERNEL(GGPUOrS, cv::gapi::core::GOrS) +{ + static void run(const cv::UMat& a, const cv::Scalar& b, cv::UMat& out) + { + cv::bitwise_or(a, b, out); + } +}; + +GAPI_GPU_KERNEL(GGPUXor, cv::gapi::core::GXor) +{ + static void run(const cv::UMat& a, const cv::UMat& b, cv::UMat& out) + { + cv::bitwise_xor(a, b, out); + } +}; + +GAPI_GPU_KERNEL(GGPUXorS, cv::gapi::core::GXorS) +{ + static void run(const cv::UMat& a, const cv::Scalar& b, cv::UMat& out) + { + cv::bitwise_xor(a, b, out); + } +}; + +GAPI_GPU_KERNEL(GGPUNot, cv::gapi::core::GNot) +{ + static void run(const cv::UMat& a, cv::UMat& out) + { + cv::bitwise_not(a, out); + } +}; + +GAPI_GPU_KERNEL(GGPUSelect, cv::gapi::core::GSelect) +{ + static void run(const cv::UMat& src1, const cv::UMat& src2, const cv::UMat& mask, cv::UMat& out) + { + src2.copyTo(out); + src1.copyTo(out, mask); + } +}; + +////TODO: doesn't compiled with UMat +//GAPI_GPU_KERNEL(GGPUMin, cv::gapi::core::GMin) +//{ +// static void run(const cv::UMat& in1, const cv::UMat& in2, cv::UMat& out) +// { +// out = cv::min(in1, in2); +// } +//}; +// +////TODO: doesn't compiled with UMat +//GAPI_GPU_KERNEL(GGPUMax, cv::gapi::core::GMax) +//{ +// static void run(const cv::UMat& in1, const cv::UMat& in2, cv::UMat& out) +// { +// out = cv::max(in1, in2); +// } +//}; + + +GAPI_GPU_KERNEL(GGPUAbsDiff, cv::gapi::core::GAbsDiff) +{ + static void run(const cv::UMat& in1, const cv::UMat& in2, cv::UMat& out) + { + cv::absdiff(in1, in2, out); + } +}; + +GAPI_GPU_KERNEL(GGPUAbsDiffC, cv::gapi::core::GAbsDiffC) +{ + static void run(const cv::UMat& in1, const cv::Scalar& in2, cv::UMat& out) + { + cv::absdiff(in1, in2, out); + } +}; + +GAPI_GPU_KERNEL(GGPUSum, cv::gapi::core::GSum) +{ + static void run(const cv::UMat& in, cv::Scalar& out) + { + out = cv::sum(in); + } +}; + +GAPI_GPU_KERNEL(GGPUAddW, cv::gapi::core::GAddW) +{ + static void run(const cv::UMat& in1, double alpha, const cv::UMat& in2, double beta, double gamma, int dtype, cv::UMat& out) + { + cv::addWeighted(in1, alpha, in2, beta, gamma, out, dtype); + } +}; + + +GAPI_GPU_KERNEL(GGPUNormL1, cv::gapi::core::GNormL1) +{ + static void run(const cv::UMat& in, cv::Scalar& out) + { + out = cv::norm(in, cv::NORM_L1); + } +}; + +GAPI_GPU_KERNEL(GGPUNormL2, cv::gapi::core::GNormL2) +{ + static void run(const cv::UMat& in, cv::Scalar& out) + { + out = cv::norm(in, cv::NORM_L2); + } +}; + +GAPI_GPU_KERNEL(GGPUNormInf, cv::gapi::core::GNormInf) +{ + static void run(const cv::UMat& in, cv::Scalar& out) + { + out = cv::norm(in, cv::NORM_INF); + } +}; + +GAPI_GPU_KERNEL(GGPUIntegral, cv::gapi::core::GIntegral) +{ + static void run(const cv::UMat& in, int sdepth, int sqdepth, cv::UMat& out, cv::UMat& outSq) + { + cv::integral(in, out, outSq, sdepth, sqdepth); + } +}; + +GAPI_GPU_KERNEL(GGPUThreshold, cv::gapi::core::GThreshold) +{ + static void run(const cv::UMat& in, const cv::Scalar& a, const cv::Scalar& b, int type, cv::UMat& out) + { + cv::threshold(in, out, a.val[0], b.val[0], type); + } +}; + +GAPI_GPU_KERNEL(GGPUThresholdOT, cv::gapi::core::GThresholdOT) +{ + static void run(const cv::UMat& in, const cv::Scalar& b, int type, cv::UMat& out, cv::Scalar& outScalar) + { + outScalar = cv::threshold(in, out, b.val[0], b.val[0], type); + } +}; + + +GAPI_GPU_KERNEL(GGPUInRange, cv::gapi::core::GInRange) +{ + static void run(const cv::UMat& in, const cv::Scalar& low, const cv::Scalar& up, cv::UMat& out) + { + cv::inRange(in, low, up, out); + } +}; + +GAPI_GPU_KERNEL(GGPUSplit3, cv::gapi::core::GSplit3) +{ + static void run(const cv::UMat& in, cv::UMat &m1, cv::UMat &m2, cv::UMat &m3) + { + std::vector outMats = {m1, m2, m3}; + cv::split(in, outMats); + + // Write back FIXME: Write a helper or avoid this nonsence completely! + m1 = outMats[0]; + m2 = outMats[1]; + m3 = outMats[2]; + } +}; + +GAPI_GPU_KERNEL(GGPUSplit4, cv::gapi::core::GSplit4) +{ + static void run(const cv::UMat& in, cv::UMat &m1, cv::UMat &m2, cv::UMat &m3, cv::UMat &m4) + { + std::vector outMats = {m1, m2, m3, m4}; + cv::split(in, outMats); + + // Write back FIXME: Write a helper or avoid this nonsence completely! + m1 = outMats[0]; + m2 = outMats[1]; + m3 = outMats[2]; + m4 = outMats[3]; + } +}; + +GAPI_GPU_KERNEL(GGPUMerge3, cv::gapi::core::GMerge3) +{ + static void run(const cv::UMat& in1, const cv::UMat& in2, const cv::UMat& in3, cv::UMat &out) + { + std::vector inMats = {in1, in2, in3}; + cv::merge(inMats, out); + } +}; + +GAPI_GPU_KERNEL(GGPUMerge4, cv::gapi::core::GMerge4) +{ + static void run(const cv::UMat& in1, const cv::UMat& in2, const cv::UMat& in3, const cv::UMat& in4, cv::UMat &out) + { + std::vector inMats = {in1, in2, in3, in4}; + cv::merge(inMats, out); + } +}; + +GAPI_GPU_KERNEL(GGPUResize, cv::gapi::core::GResize) +{ + static void run(const cv::UMat& in, cv::Size sz, double fx, double fy, int interp, cv::UMat &out) + { + cv::resize(in, out, sz, fx, fy, interp); + } +}; + +GAPI_GPU_KERNEL(GGPURemap, cv::gapi::core::GRemap) +{ + static void run(const cv::UMat& in, const cv::Mat& x, const cv::Mat& y, int a, int b, cv::Scalar s, cv::UMat& out) + { + cv::remap(in, out, x, y, a, b, s); + } +}; + +GAPI_GPU_KERNEL(GGPUFlip, cv::gapi::core::GFlip) +{ + static void run(const cv::UMat& in, int code, cv::UMat& out) + { + cv::flip(in, out, code); + } +}; + +GAPI_GPU_KERNEL(GGPUCrop, cv::gapi::core::GCrop) +{ + static void run(const cv::UMat& in, cv::Rect rect, cv::UMat& out) + { + cv::UMat(in, rect).copyTo(out); + } +}; + +GAPI_GPU_KERNEL(GGPUConcatHor, cv::gapi::core::GConcatHor) +{ + static void run(const cv::UMat& in1, const cv::UMat& in2, cv::UMat& out) + { + cv::hconcat(in1, in2, out); + } +}; + +GAPI_GPU_KERNEL(GGPUConcatVert, cv::gapi::core::GConcatVert) +{ + static void run(const cv::UMat& in1, const cv::UMat& in2, cv::UMat& out) + { + cv::vconcat(in1, in2, out); + } +}; + +GAPI_GPU_KERNEL(GGPULUT, cv::gapi::core::GLUT) +{ + static void run(const cv::UMat& in, const cv::Mat& lut, cv::UMat& out) + { + cv::LUT(in, lut, out); + } +}; + +GAPI_GPU_KERNEL(GGPUConvertTo, cv::gapi::core::GConvertTo) +{ + static void run(const cv::UMat& in, int rtype, double alpha, double beta, cv::UMat& out) + { + in.convertTo(out, rtype, alpha, beta); + } +}; + +cv::gapi::GKernelPackage cv::gapi::core::gpu::kernels() +{ + static auto pkg = cv::gapi::kernels + < GGPUAdd + , GGPUAddC + , GGPUSub + , GGPUSubC + , GGPUSubRC + , GGPUMul + , GGPUMulC + , GGPUMulCOld + , GGPUDiv + , GGPUDivC + , GGPUDivRC + , GGPUMean + , GGPUMask + , GGPUPolarToCart + , GGPUCartToPolar + , GGPUCmpGT + , GGPUCmpGE + , GGPUCmpLE + , GGPUCmpLT + , GGPUCmpEQ + , GGPUCmpNE + , GGPUCmpGTScalar + , GGPUCmpGEScalar + , GGPUCmpLEScalar + , GGPUCmpLTScalar + , GGPUCmpEQScalar + , GGPUCmpNEScalar + , GGPUAnd + , GGPUAndS + , GGPUOr + , GGPUOrS + , GGPUXor + , GGPUXorS + , GGPUNot + , GGPUSelect + //, GGPUMin + //, GGPUMax + , GGPUAbsDiff + , GGPUAbsDiffC + , GGPUSum + , GGPUAddW + , GGPUNormL1 + , GGPUNormL2 + , GGPUNormInf + , GGPUIntegral + , GGPUThreshold + , GGPUThresholdOT + , GGPUInRange + , GGPUSplit3 + , GGPUSplit4 + , GGPUResize + , GGPUMerge3 + , GGPUMerge4 + , GGPURemap + , GGPUFlip + , GGPUCrop + , GGPUConcatHor + , GGPUConcatVert + , GGPULUT + , GGPUConvertTo + >(); + return pkg; +} diff --git a/modules/gapi/src/backends/gpu/ggpucore.hpp b/modules/gapi/src/backends/gpu/ggpucore.hpp new file mode 100644 index 0000000000..47cbfa6bdd --- /dev/null +++ b/modules/gapi/src/backends/gpu/ggpucore.hpp @@ -0,0 +1,24 @@ +// This file is part of OpenCV project. +// It is subject to the license terms in the LICENSE file found in the top-level directory +// of this distribution and at http://opencv.org/license.html. +// +// Copyright (C) 2018 Intel Corporation + + +#ifndef OPENCV_GAPI_GGPUCORE_HPP +#define OPENCV_GAPI_GGPUCORE_HPP + +#include +#include + +#include "opencv2/gapi/gpu/ggpukernel.hpp" + +namespace cv { namespace gimpl { + +// NB: This is what a "Kernel Package" from the original Wiki doc should be. +void loadGPUCore(std::map &kmap); + +} +} + +#endif // OPENCV_GAPI_GGPUCORE_HPP diff --git a/modules/gapi/src/backends/gpu/ggpuimgproc.cpp b/modules/gapi/src/backends/gpu/ggpuimgproc.cpp new file mode 100644 index 0000000000..9b7aca1a26 --- /dev/null +++ b/modules/gapi/src/backends/gpu/ggpuimgproc.cpp @@ -0,0 +1,277 @@ +// This file is part of OpenCV project. +// It is subject to the license terms in the LICENSE file found in the top-level directory +// of this distribution and at http://opencv.org/license.html. +// +// Copyright (C) 2018 Intel Corporation + + +#include "precomp.hpp" + +#include "opencv2/gapi/imgproc.hpp" +#include "opencv2/gapi/gpu/imgproc.hpp" +#include "backends/gpu/ggpuimgproc.hpp" + + +GAPI_GPU_KERNEL(GGPUSepFilter, cv::gapi::imgproc::GSepFilter) +{ + static void run(const cv::UMat& in, int ddepth, const cv::Mat& kernX, const cv::Mat& kernY, const cv::Point& anchor, const cv::Scalar& delta, + int border, const cv::Scalar& bordVal, cv::UMat &out) + { + if( border == cv::BORDER_CONSTANT ) + { + cv::UMat temp_in; + int width_add = (kernY.cols - 1) / 2; + int height_add = (kernX.rows - 1) / 2; + cv::copyMakeBorder(in, temp_in, height_add, height_add, width_add, width_add, border, bordVal); + cv::Rect rect = cv::Rect(height_add, width_add, in.cols, in.rows); + cv::sepFilter2D(temp_in(rect), out, ddepth, kernX, kernY, anchor, delta.val[0], border); + } + else + cv::sepFilter2D(in, out, ddepth, kernX, kernY, anchor, delta.val[0], border); + } +}; + +GAPI_GPU_KERNEL(GGPUBoxFilter, cv::gapi::imgproc::GBoxFilter) +{ + static void run(const cv::UMat& in, int ddepth, const cv::Size& ksize, const cv::Point& anchor, bool normalize, int borderType, const cv::Scalar& bordVal, cv::UMat &out) + { + if( borderType == cv::BORDER_CONSTANT ) + { + cv::UMat temp_in; + int width_add = (ksize.width - 1) / 2; + int height_add = (ksize.height - 1) / 2; + cv::copyMakeBorder(in, temp_in, height_add, height_add, width_add, width_add, borderType, bordVal); + cv::Rect rect = cv::Rect(height_add, width_add, in.cols, in.rows); + cv::boxFilter(temp_in(rect), out, ddepth, ksize, anchor, normalize, borderType); + } + else + cv::boxFilter(in, out, ddepth, ksize, anchor, normalize, borderType); + } +}; + +GAPI_GPU_KERNEL(GGPUBlur, cv::gapi::imgproc::GBlur) +{ + static void run(const cv::UMat& in, const cv::Size& ksize, const cv::Point& anchor, int borderType, const cv::Scalar& bordVal, cv::UMat &out) + { + if( borderType == cv::BORDER_CONSTANT ) + { + cv::UMat temp_in; + int width_add = (ksize.width - 1) / 2; + int height_add = (ksize.height - 1) / 2; + cv::copyMakeBorder(in, temp_in, height_add, height_add, width_add, width_add, borderType, bordVal); + cv::Rect rect = cv::Rect(height_add, width_add, in.cols, in.rows); + cv::blur(temp_in(rect), out, ksize, anchor, borderType); + } + else + cv::blur(in, out, ksize, anchor, borderType); + } +}; + + +GAPI_GPU_KERNEL(GGPUFilter2D, cv::gapi::imgproc::GFilter2D) +{ + static void run(const cv::UMat& in, int ddepth, const cv::Mat& k, const cv::Point& anchor, const cv::Scalar& delta, int border, + const cv::Scalar& bordVal, cv::UMat &out) + { + if( border == cv::BORDER_CONSTANT ) + { + cv::UMat temp_in; + int width_add = (k.cols - 1) / 2; + int height_add = (k.rows - 1) / 2; + cv::copyMakeBorder(in, temp_in, height_add, height_add, width_add, width_add, border, bordVal ); + cv::Rect rect = cv::Rect(height_add, width_add, in.cols, in.rows); + cv::filter2D(temp_in(rect), out, ddepth, k, anchor, delta.val[0], border); + } + else + cv::filter2D(in, out, ddepth, k, anchor, delta.val[0], border); + } +}; + +GAPI_GPU_KERNEL(GGPUGaussBlur, cv::gapi::imgproc::GGaussBlur) +{ + static void run(const cv::UMat& in, const cv::Size& ksize, double sigmaX, double sigmaY, int borderType, const cv::Scalar& bordVal, cv::UMat &out) + { + if( borderType == cv::BORDER_CONSTANT ) + { + cv::UMat temp_in; + int width_add = (ksize.width - 1) / 2; + int height_add = (ksize.height - 1) / 2; + cv::copyMakeBorder(in, temp_in, height_add, height_add, width_add, width_add, borderType, bordVal ); + cv::Rect rect = cv::Rect(height_add, width_add, in.cols, in.rows); + cv::GaussianBlur(temp_in(rect), out, ksize, sigmaX, sigmaY, borderType); + } + else + cv::GaussianBlur(in, out, ksize, sigmaX, sigmaY, borderType); + } +}; + +GAPI_GPU_KERNEL(GGPUMedianBlur, cv::gapi::imgproc::GMedianBlur) +{ + static void run(const cv::UMat& in, int ksize, cv::UMat &out) + { + cv::medianBlur(in, out, ksize); + } +}; + +GAPI_GPU_KERNEL(GGPUErode, cv::gapi::imgproc::GErode) +{ + static void run(const cv::UMat& in, const cv::Mat& kernel, const cv::Point& anchor, int iterations, int borderType, const cv::Scalar& borderValue, cv::UMat &out) + { + cv::erode(in, out, kernel, anchor, iterations, borderType, borderValue); + } +}; + +GAPI_GPU_KERNEL(GGPUDilate, cv::gapi::imgproc::GDilate) +{ + static void run(const cv::UMat& in, const cv::Mat& kernel, const cv::Point& anchor, int iterations, int borderType, const cv::Scalar& borderValue, cv::UMat &out) + { + cv::dilate(in, out, kernel, anchor, iterations, borderType, borderValue); + } +}; + +GAPI_GPU_KERNEL(GGPUSobel, cv::gapi::imgproc::GSobel) +{ + static void run(const cv::UMat& in, int ddepth, int dx, int dy, int ksize, double scale, double delta, int borderType, + const cv::Scalar& bordVal, cv::UMat &out) + { + if( borderType == cv::BORDER_CONSTANT ) + { + cv::UMat temp_in; + int add = (ksize - 1) / 2; + cv::copyMakeBorder(in, temp_in, add, add, add, add, borderType, bordVal ); + cv::Rect rect = cv::Rect(add, add, in.cols, in.rows); + cv::Sobel(temp_in(rect), out, ddepth, dx, dy, ksize, scale, delta, borderType); + } + else + cv::Sobel(in, out, ddepth, dx, dy, ksize, scale, delta, borderType); + } +}; + +GAPI_GPU_KERNEL(GGPUEqualizeHist, cv::gapi::imgproc::GEqHist) +{ + static void run(const cv::UMat& in, cv::UMat &out) + { + cv::equalizeHist(in, out); + } +}; + +GAPI_GPU_KERNEL(GGPUCanny, cv::gapi::imgproc::GCanny) +{ + static void run(const cv::UMat& in, double thr1, double thr2, int apSize, bool l2gradient, cv::UMat &out) + { + cv::Canny(in, out, thr1, thr2, apSize, l2gradient); + } +}; + +GAPI_GPU_KERNEL(GGPURGB2YUV, cv::gapi::imgproc::GRGB2YUV) +{ + static void run(const cv::UMat& in, cv::UMat &out) + { + cv::cvtColor(in, out, cv::COLOR_RGB2YUV); + } +}; + +GAPI_GPU_KERNEL(GGPUYUV2RGB, cv::gapi::imgproc::GYUV2RGB) +{ + static void run(const cv::UMat& in, cv::UMat &out) + { + cv::cvtColor(in, out, cv::COLOR_YUV2RGB); + } +}; + +GAPI_GPU_KERNEL(GGPURGB2Lab, cv::gapi::imgproc::GRGB2Lab) +{ + static void run(const cv::UMat& in, cv::UMat &out) + { + cv::cvtColor(in, out, cv::COLOR_RGB2Lab); + } +}; + +GAPI_GPU_KERNEL(GGPUBGR2LUV, cv::gapi::imgproc::GBGR2LUV) +{ + static void run(const cv::UMat& in, cv::UMat &out) + { + cv::cvtColor(in, out, cv::COLOR_BGR2Luv); + } +}; + +GAPI_GPU_KERNEL(GGPUBGR2YUV, cv::gapi::imgproc::GBGR2YUV) +{ + static void run(const cv::UMat& in, cv::UMat &out) + { + cv::cvtColor(in, out, cv::COLOR_BGR2YUV); + } +}; + +GAPI_GPU_KERNEL(GGPULUV2BGR, cv::gapi::imgproc::GLUV2BGR) +{ + static void run(const cv::UMat& in, cv::UMat &out) + { + cv::cvtColor(in, out, cv::COLOR_Luv2BGR); + } +}; + +GAPI_GPU_KERNEL(GGPUYUV2BGR, cv::gapi::imgproc::GYUV2BGR) +{ + static void run(const cv::UMat& in, cv::UMat &out) + { + cv::cvtColor(in, out, cv::COLOR_YUV2BGR); + } +}; + +GAPI_GPU_KERNEL(GGPURGB2Gray, cv::gapi::imgproc::GRGB2Gray) +{ + static void run(const cv::UMat& in, cv::UMat &out) + { + cv::cvtColor(in, out, cv::COLOR_RGB2GRAY); + } +}; + +GAPI_GPU_KERNEL(GGPUBGR2Gray, cv::gapi::imgproc::GBGR2Gray) +{ + static void run(const cv::UMat& in, cv::UMat &out) + { + cv::cvtColor(in, out, cv::COLOR_BGR2GRAY); + } +}; + +GAPI_GPU_KERNEL(GGPURGB2GrayCustom, cv::gapi::imgproc::GRGB2GrayCustom) +{ + //TODO: avoid copy + static void run(const cv::UMat& in, float rY, float bY, float gY, cv::UMat &out) + { + cv::Mat planes[3]; + cv::split(in.getMat(cv::ACCESS_READ), planes); + cv::Mat tmp_out = (planes[0]*rY + planes[1]*bY + planes[2]*gY); + tmp_out.copyTo(out); + } +}; + + +cv::gapi::GKernelPackage cv::gapi::imgproc::gpu::kernels() +{ + static auto pkg = cv::gapi::kernels + < GGPUFilter2D + , GGPUSepFilter + , GGPUBoxFilter + , GGPUBlur + , GGPUGaussBlur + , GGPUMedianBlur + , GGPUErode + , GGPUDilate + , GGPUSobel + , GGPUCanny + , GGPUEqualizeHist + , GGPURGB2YUV + , GGPUYUV2RGB + , GGPURGB2Lab + , GGPUBGR2LUV + , GGPUBGR2YUV + , GGPUYUV2BGR + , GGPULUV2BGR + , GGPUBGR2Gray + , GGPURGB2Gray + , GGPURGB2GrayCustom + >(); + return pkg; +} diff --git a/modules/gapi/src/backends/gpu/ggpuimgproc.hpp b/modules/gapi/src/backends/gpu/ggpuimgproc.hpp new file mode 100644 index 0000000000..cd2e324e61 --- /dev/null +++ b/modules/gapi/src/backends/gpu/ggpuimgproc.hpp @@ -0,0 +1,23 @@ +// This file is part of OpenCV project. +// It is subject to the license terms in the LICENSE file found in the top-level directory +// of this distribution and at http://opencv.org/license.html. +// +// Copyright (C) 2018 Intel Corporation + + +#ifndef OPENCV_GAPI_GGPUIMGPROC_HPP +#define OPENCV_GAPI_GGPUIMGPROC_HPP + +#include +#include + +#include "opencv2/gapi/gpu/ggpukernel.hpp" + +namespace cv { namespace gimpl { + +// NB: This is what a "Kernel Package" from the origianl Wiki doc should be. +void loadGPUImgProc(std::map &kmap); + +}} + +#endif // OPENCV_GAPI_GGPUIMGPROC_HPP diff --git a/modules/gapi/src/backends/gpu/ggpukernel.cpp b/modules/gapi/src/backends/gpu/ggpukernel.cpp new file mode 100644 index 0000000000..87e2aa97e9 --- /dev/null +++ b/modules/gapi/src/backends/gpu/ggpukernel.cpp @@ -0,0 +1,50 @@ +// This file is part of OpenCV project. +// It is subject to the license terms in the LICENSE file found in the top-level directory +// of this distribution and at http://opencv.org/license.html. +// +// Copyright (C) 2018 Intel Corporation + + +#include + +#include "opencv2/gapi/gpu/ggpukernel.hpp" + +const cv::UMat& cv::GGPUContext::inMat(int input) +{ + return (inArg(input)); +} + +cv::UMat& cv::GGPUContext::outMatR(int output) +{ + return (*(util::get(m_results.at(output)))); +} + +const cv::gapi::own::Scalar& cv::GGPUContext::inVal(int input) +{ + return inArg(input); +} + +cv::gapi::own::Scalar& cv::GGPUContext::outValR(int output) +{ + return *util::get(m_results.at(output)); +} + +cv::detail::VectorRef& cv::GGPUContext::outVecRef(int output) +{ + return util::get(m_results.at(output)); +} + +cv::GGPUKernel::GGPUKernel() +{ +} + +cv::GGPUKernel::GGPUKernel(const GGPUKernel::F &f) + : m_f(f) +{ +} + +void cv::GGPUKernel::apply(GGPUContext &ctx) +{ + CV_Assert(m_f); + m_f(ctx); +} diff --git a/modules/gapi/test/common/gapi_core_tests.hpp b/modules/gapi/test/common/gapi_core_tests.hpp index b0b15a502a..733b2f7a02 100644 --- a/modules/gapi/test/common/gapi_core_tests.hpp +++ b/modules/gapi/test/common/gapi_core_tests.hpp @@ -124,17 +124,17 @@ struct MinTest : public TestParams>{}; struct AbsDiffTest : public TestParams>{}; struct AbsDiffCTest : public TestParams> {}; -struct SumTest : public TestParams> {}; -struct AddWeightedTest : public TestParams>{}; -struct NormTest : public TestParams>{}; +struct SumTest : public TestParams> {}; +struct AddWeightedTest : public TestParams>{}; +struct NormTest : public TestParams>{}; struct IntegralTest : public TestWithParam> {}; struct ThresholdTest : public TestParams> {}; struct ThresholdOTTest : public TestParams> {}; struct InRangeTest : public TestParams> {}; struct Split3Test : public TestParams> {}; struct Split4Test : public TestParams> {}; -struct ResizeTest : public TestWithParam> {}; -struct ResizeTestFxFy : public TestWithParam> {}; +struct ResizeTest : public TestWithParam> {}; +struct ResizeTestFxFy : public TestWithParam> {}; struct Merge3Test : public TestParams> {}; struct Merge4Test : public TestParams> {}; struct RemapTest : public TestParams> {}; diff --git a/modules/gapi/test/common/gapi_core_tests_inl.hpp b/modules/gapi/test/common/gapi_core_tests_inl.hpp index 7d413ca0c7..c226edd505 100644 --- a/modules/gapi/test/common/gapi_core_tests_inl.hpp +++ b/modules/gapi/test/common/gapi_core_tests_inl.hpp @@ -682,8 +682,11 @@ TEST_P(SumTest, AccuracyTest) { auto param = GetParam(); cv::Size sz_in = std::get<1>(param); - auto compile_args = std::get<3>(param); - initMatrixRandU(std::get<0>(param), sz_in, std::get<2>(param)); + auto tolerance = std::get<3>(param); + auto compile_args = std::get<4>(param); + //initMatrixRandU(std::get<0>(param), sz_in, std::get<2>(param)); + initMatsRandN(std::get<0>(param), sz_in, std::get<2>(param)); //TODO: workaround trying to fix SumTest failures + cv::Scalar out_sum; cv::Scalar out_sum_ocv; @@ -700,7 +703,7 @@ TEST_P(SumTest, AccuracyTest) } // Comparison ////////////////////////////////////////////////////////////// { - EXPECT_EQ(out_sum[0], out_sum_ocv[0]); + EXPECT_LE(abs(out_sum[0] - out_sum_ocv[0]), tolerance); } } @@ -710,7 +713,8 @@ TEST_P(AddWeightedTest, AccuracyTest) cv::Size sz_in; bool initOut = false; cv::GCompileArgs compile_args; - std::tie(type, sz_in, dtype, initOut, compile_args) = GetParam(); + double tolerance = 0.0; + std::tie(type, sz_in, dtype, initOut, tolerance, compile_args) = GetParam(); auto& rng = cv::theRNG(); double alpha = rng.uniform(0.0, 1.0); @@ -759,7 +763,7 @@ TEST_P(AddWeightedTest, AccuracyTest) // even if rounded differently, check if still rounded correctly cv::addWeighted(in_mat1, alpha, in_mat2, beta, gamma, tmp, CV_32F); cv::subtract(out_mat_gapi, tmp, diff, cv::noArray(), CV_32F); - incorrect = abs(diff) >= 0.5000005f; // relative to 6 digits + incorrect = abs(diff) >= tolerance;// 0.5000005f; // relative to 6 digits failures = inexact & incorrect; } @@ -774,8 +778,9 @@ TEST_P(NormTest, AccuracyTest) NormTypes opType = NORM_INF; int type = 0; cv::Size sz; + double tolerance = 0.0; cv::GCompileArgs compile_args; - std::tie(opType, type, sz, compile_args) = GetParam(); + std::tie(opType, type, sz, tolerance, compile_args) = GetParam(); initMatrixRandU(type, sz, type, false); cv::Scalar out_norm; @@ -797,7 +802,7 @@ TEST_P(NormTest, AccuracyTest) // Comparison ////////////////////////////////////////////////////////////// { - EXPECT_EQ(out_norm[0], out_norm_ocv[0]); + EXPECT_LE(abs(out_norm[0] - out_norm_ocv[0]), tolerance); } } @@ -845,9 +850,8 @@ TEST_P(ThresholdTest, AccuracyTestBinary) int tt = std::get<2>(param); auto compile_args = std::get<4>(param); - auto& rng = cv::theRNG(); - cv::Scalar thr = cv::Scalar(rng(50),rng(50),rng(50),rng(50)); - cv::Scalar maxval = cv::Scalar(50 + rng(50),50 + rng(50),50 + rng(50),50 + rng(50)); + cv::Scalar thr = initScalarRandU(50); + cv::Scalar maxval = initScalarRandU(50) + cv::Scalar(50, 50, 50, 50); initMatrixRandU(type, sz_in, type, std::get<3>(param)); cv::Scalar out_scalar; @@ -994,7 +998,7 @@ TEST_P(Split4Test, AccuracyTest) } } -static void ResizeAccuracyTest(int type, int interp, cv::Size sz_in, cv::Size sz_out, double fx, double fy, double tolerance, cv::GCompileArgs&& compile_args) +static void ResizeAccuracyTest(compare_f cmpF, int type, int interp, cv::Size sz_in, cv::Size sz_out, double fx, double fy, cv::GCompileArgs&& compile_args) { cv::Mat in_mat1 (sz_in, type ); cv::Scalar mean = cv::Scalar::all(127); @@ -1020,30 +1024,29 @@ static void ResizeAccuracyTest(int type, int interp, cv::Size sz_in, cv::Size sz } // Comparison ////////////////////////////////////////////////////////////// { - cv::Mat absDiff; - cv::absdiff(out_mat, out_mat_ocv, absDiff); - EXPECT_EQ(0, cv::countNonZero(absDiff > tolerance)); + EXPECT_TRUE(cmpF(out_mat, out_mat_ocv)); } } TEST_P(ResizeTest, AccuracyTest) { + compare_f cmpF; int type = 0, interp = 0; cv::Size sz_in, sz_out; - double tolerance = 0.0; cv::GCompileArgs compile_args; - std::tie(type, interp, sz_in, sz_out, tolerance, compile_args) = GetParam(); - ResizeAccuracyTest(type, interp, sz_in, sz_out, 0.0, 0.0, tolerance, std::move(compile_args)); + std::tie(cmpF, type, interp, sz_in, sz_out, compile_args) = GetParam(); + ResizeAccuracyTest(cmpF, type, interp, sz_in, sz_out, 0.0, 0.0, std::move(compile_args)); } TEST_P(ResizeTestFxFy, AccuracyTest) { + compare_f cmpF; int type = 0, interp = 0; cv::Size sz_in; - double fx = 0.0, fy = 0.0, tolerance = 0.0; + double fx = 0.0, fy = 0.0; cv::GCompileArgs compile_args; - std::tie(type, interp, sz_in, fx, fy, tolerance, compile_args) = GetParam(); - ResizeAccuracyTest(type, interp, sz_in, cv::Size{0, 0}, fx, fy, tolerance, std::move(compile_args)); + std::tie(cmpF, type, interp, sz_in, fx, fy, compile_args) = GetParam(); + ResizeAccuracyTest(cmpF, type, interp, sz_in, cv::Size{0, 0}, fx, fy, std::move(compile_args)); } TEST_P(Merge3Test, AccuracyTest) diff --git a/modules/gapi/test/common/gapi_operators_tests.hpp b/modules/gapi/test/common/gapi_operators_tests.hpp index 5a5a53fed4..9f53d36857 100644 --- a/modules/gapi/test/common/gapi_operators_tests.hpp +++ b/modules/gapi/test/common/gapi_operators_tests.hpp @@ -184,8 +184,8 @@ g_api_ocv_pair_mat_mat opXor = {std::string{"operator^"}, [](const cv::Mat& in1, const cv::Mat& in2, cv::Mat& out){cv::bitwise_xor(in1, in2, out);}}; } // anonymous namespace -struct MathOperatorMatScalarTest : public TestParams>{}; -struct MathOperatorMatMatTest : public TestParams>{}; +struct MathOperatorMatScalarTest : public TestParams>{}; +struct MathOperatorMatMatTest : public TestParams>{}; struct NotOperatorTest : public TestParams> {}; } // opencv_test diff --git a/modules/gapi/test/common/gapi_operators_tests_inl.hpp b/modules/gapi/test/common/gapi_operators_tests_inl.hpp index 5ac0e36210..7ec702ae9b 100644 --- a/modules/gapi/test/common/gapi_operators_tests_inl.hpp +++ b/modules/gapi/test/common/gapi_operators_tests_inl.hpp @@ -14,12 +14,13 @@ namespace opencv_test { TEST_P(MathOperatorMatScalarTest, OperatorAccuracyTest ) { + compare_f cmpF; g_api_ocv_pair_mat_scalar op; int type = 0, dtype = 0; cv::Size sz; bool initOutMatr = false; cv::GCompileArgs compile_args; - std::tie(op, type, sz, dtype, initOutMatr, compile_args) = GetParam(); + std::tie(cmpF, op, type, sz, dtype, initOutMatr, compile_args) = GetParam(); initMatsRandU(type, sz, dtype, initOutMatr); auto fun_gapi = op.g_api_function; @@ -38,19 +39,20 @@ TEST_P(MathOperatorMatScalarTest, OperatorAccuracyTest ) // Comparison ////////////////////////////////////////////////////////////// { - EXPECT_EQ(0, cv::countNonZero(out_mat_gapi != out_mat_ocv)); + EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv)); EXPECT_EQ(out_mat_gapi.size(), sz); } } TEST_P(MathOperatorMatMatTest, OperatorAccuracyTest ) { + compare_f cmpF; g_api_ocv_pair_mat_mat op; int type = 0, dtype = 0; cv::Size sz; bool initOutMatr = false; cv::GCompileArgs compile_args; - std::tie(op, type, sz, dtype, initOutMatr, compile_args) = GetParam(); + std::tie(cmpF, op, type, sz, dtype, initOutMatr, compile_args) = GetParam(); initMatsRandU(type, sz, dtype, initOutMatr); auto fun_gapi = op.g_api_function; @@ -69,7 +71,7 @@ TEST_P(MathOperatorMatMatTest, OperatorAccuracyTest ) // Comparison ////////////////////////////////////////////////////////////// { - EXPECT_EQ(0, cv::countNonZero(out_mat_gapi != out_mat_ocv)); + EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv)); EXPECT_EQ(out_mat_gapi.size(), sz); } } diff --git a/modules/gapi/test/common/gapi_tests_common.hpp b/modules/gapi/test/common/gapi_tests_common.hpp index 2a9b3f5dfa..864e2cdfc4 100644 --- a/modules/gapi/test/common/gapi_tests_common.hpp +++ b/modules/gapi/test/common/gapi_tests_common.hpp @@ -128,4 +128,255 @@ struct Wrappable } }; +class AbsExact : public Wrappable +{ +public: + AbsExact() {} + bool operator() (const cv::Mat& in1, const cv::Mat& in2) const + { + if (cv::countNonZero(in1 != in2) != 0) + { + std::cout << "AbsExact error: G-API output and reference output matrixes are not bitexact equal." << std::endl; + return false; + } + else + { + return true; + } + } +private: +}; + +class AbsTolerance : public Wrappable +{ +public: + AbsTolerance(double tol) : _tol(tol) {} + bool operator() (const cv::Mat& in1, const cv::Mat& in2) const + { + cv::Mat absDiff; cv::absdiff(in1, in2, absDiff); + if(cv::countNonZero(absDiff > _tol)) + { + std::cout << "AbsTolerance error: Number of different pixels in " << std::endl; + std::cout << "G-API output and reference output matrixes exceeds " << _tol << " pixels threshold." << std::endl; + return false; + } + else + { + return true; + } + } +private: + double _tol; +}; + +class AbsTolerance_Float_Int : public Wrappable +{ +public: + AbsTolerance_Float_Int(double tol, double tol8u) : _tol(tol), _tol8u(tol8u) {} + bool operator() (const cv::Mat& in1, const cv::Mat& in2) const + { + if (CV_MAT_DEPTH(in1.type()) == CV_32F) + { + if (cv::countNonZero(cv::abs(in1 - in2) > (_tol)*cv::abs(in2))) + { + std::cout << "AbsTolerance_Float_Int error (Float): One or more of pixels in" << std::endl; + std::cout << "G-API output exceeds relative threshold value defined by reference_pixel_value * tolerance" << std::endl; + std::cout << "for tolerance " << _tol << std::endl; + return false; + } + else + { + return true; + } + } + else + { + if (cv::countNonZero(in1 != in2) <= (_tol8u)* in2.total()) + { + return true; + } + else + { + std::cout << "AbsTolerance_Float_Int error (Integer): Number of different pixels in" << std::endl; + std::cout << "G-API output and reference output matrixes exceeds relative threshold value" << std::endl; + std::cout << "defined by reference_total_pixels_number * tolerance" << std::endl; + std::cout << "for tolerance " << _tol8u << std::endl; + return false; + } + } + } +private: + double _tol; + double _tol8u; +}; + +class AbsToleranceSepFilter : public Wrappable +{ +public: + AbsToleranceSepFilter(double tol) : _tol(tol) {} + bool operator() (const cv::Mat& in1, const cv::Mat& in2) const + { + if ((cv::countNonZero(cv::abs(in1 - in2) > (_tol)* cv::abs(in2)) <= 0.01 * in2.total())) + { + return true; + } + else + { + std::cout << "AbsToleranceSepFilter error: Number of different pixels in" << std::endl; + std::cout << "G-API output and reference output matrixes which exceeds relative threshold value" << std::endl; + std::cout << "defined by reference_pixel_value * tolerance" << std::endl; + std::cout << "for tolerance " << _tol << " is more then 1% of total number of pixels in the reference matrix." << std::endl; + return false; + } + } +private: + double _tol; +}; + +class AbsToleranceGaussianBlur_Float_Int : public Wrappable +{ +public: + AbsToleranceGaussianBlur_Float_Int(double tol, double tol8u) : _tol(tol), _tol8u(tol8u) {} + bool operator() (const cv::Mat& in1, const cv::Mat& in2) const + { + if (CV_MAT_DEPTH(in1.type()) == CV_32F || CV_MAT_DEPTH(in1.type()) == CV_64F) + { + if (cv::countNonZero(cv::abs(in1 - in2) > (_tol)*cv::abs(in2))) + { + std::cout << "AbsToleranceGaussianBlur_Float_Int error (Float): Number of different pixels in" << std::endl; + std::cout << "G-API output and reference output matrixes which exceeds relative threshold value" << std::endl; + std::cout << "defined by reference_pixel_value * tolerance" << std::endl; + std::cout << "for tolerance " << _tol << " is more then 0." << std::endl; + return false; + } + else + { + return true; + } + } + else + { + if (CV_MAT_DEPTH(in1.type()) == CV_8U) + { + bool a = (cv::countNonZero(cv::abs(in1 - in2) > 1) <= _tol8u * in2.total()); + if (((a == 1 ? 0 : 1) && ((cv::countNonZero(cv::abs(in1 - in2) > 2) <= 0) == 1 ? 0 : 1)) == 1) + { + std::cout << "AbsToleranceGaussianBlur_Float_Int error (8U): Number of pixels in" << std::endl; + std::cout << "G-API output and reference output matrixes with absolute difference which is more than 1 but less than 3" << std::endl; + std::cout << "exceeds relative threshold value defined by reference_total_pixels_number * tolerance" << std::endl; + std::cout << "for tolerance " << _tol8u << std::endl; + return false; + } + else + { + return true; + } + } + else + { + if (cv::countNonZero(in1 != in2) != 0) + { + std::cout << "AbsToleranceGaussianBlur_Float_Int error: G-API output and reference output matrixes are not bitexact equal." << std::endl; + return false; + } + else + { + return true; + } + } + } + } +private: + double _tol; + double _tol8u; +}; + +class ToleranceRGBBGR : public Wrappable +{ +public: + ToleranceRGBBGR(double tol) : _tol(tol) {} + bool operator() (const cv::Mat& in1, const cv::Mat& in2) const + { + bool a = (cv::countNonZero((in1 - in2) > 0) <= _tol * in2.total()); + if (((a == 1 ? 0 : 1) && ((cv::countNonZero((in1 - in2) > 1) <= 0) == 1 ? 0 : 1)) == 1) + { + std::cout << "ToleranceRGBBGR error: Number of pixels in" << std::endl; + std::cout << "G-API output and reference output matrixes with difference which is more than 0 but no more than 1" << std::endl; + std::cout << "exceeds relative threshold value defined by reference_total_pixels_number * tolerance" << std::endl; + std::cout << "for tolerance " << _tol << std::endl; + return false; + } + else + { + return true; + } + } +private: + double _tol; +}; + +class ToleranceTriple: public Wrappable +{ +public: + ToleranceTriple(double tol1, double tol2, double tol3) : _tol1(tol1), _tol2(tol2), _tol3(tol3) {} + bool operator() (const cv::Mat& in1, const cv::Mat& in2) const + { + bool a = (cv::countNonZero((in1 - in2) > 0) <= _tol1 * in2.total()); + if ((((a == 1 ? 0 : 1) && + ((cv::countNonZero((in1 - in2) > 1) <= _tol2 * in2.total()) == 1 ? 0 : 1) && + ((cv::countNonZero((in1 - in2) > 2) <= _tol3 * in2.total()) == 1 ? 0 : 1))) == 1) + { + std::cout << "ToleranceTriple error: Number of pixels in" << std::endl; + std::cout << "G-API output and reference output matrixes with difference which is more than 0 but no more than 1" << std::endl; + std::cout << "exceeds relative threshold value defined by reference_total_pixels_number * tolerance1" << std::endl; + std::cout << "for tolerance1 " << _tol1 << std::endl; + std::cout << "AND with difference which is more than 1 but no more than 2" << std::endl; + std::cout << "exceeds relative threshold value defined by reference_total_pixels_number * tolerance2" << std::endl; + std::cout << "for tolerance2 " << _tol2 << std::endl; + std::cout << "AND with difference which is more than 2" << std::endl; + std::cout << "exceeds relative threshold value defined by reference_total_pixels_number * tolerance3" << std::endl; + std::cout << "for tolerance3 " << _tol3 << std::endl; + return false; + } + else + { + return true; + } + } +private: + double _tol1, _tol2, _tol3; +}; + +class AbsToleranceSobel : public Wrappable +{ +public: + AbsToleranceSobel(double tol) : _tol(tol) {} + bool operator() (const cv::Mat& in1, const cv::Mat& in2) const + { + cv::Mat diff, a1, a2, b, base; + cv::absdiff(in1, in2, diff); + a1 = cv::abs(in1); + a2 = cv::abs(in2); + cv::max(a1, a2, b); + cv::max(1, b, base); // base = max{1, |in1|, |in2|} + + if(cv::countNonZero(diff > _tol*base) != 0) + { + std::cout << "AbsToleranceSobel error: Number of pixels in" << std::endl; + std::cout << "G-API output and reference output matrixes with absolute difference which is more than relative threshold defined by tolerance * max{1, |in1|, |in2|}" << std::endl; + std::cout << "relative threshold defined by tolerance * max{1, |in1|, |in2|} exceeds 0"<< std::endl; + std::cout << "for tolerance " << _tol << std::endl; + return false; + } + else + { + return true; + } + + } +private: + double _tol; +}; + + } diff --git a/modules/gapi/test/cpu/gapi_core_tests_cpu.cpp b/modules/gapi/test/cpu/gapi_core_tests_cpu.cpp index 41d885fc1c..cc218d1028 100644 --- a/modules/gapi/test/cpu/gapi_core_tests_cpu.cpp +++ b/modules/gapi/test/cpu/gapi_core_tests_cpu.cpp @@ -14,6 +14,7 @@ namespace opencv_test { + // FIXME: Wut? See MulTestCPU/MathOpTest below (duplicate?) INSTANTIATE_TEST_CASE_P(AddTestCPU, MathOpTest, Combine(Values(ADD, MUL), @@ -187,6 +188,7 @@ INSTANTIATE_TEST_CASE_P(SumTestCPU, SumTest, cv::Size(640, 480), cv::Size(128, 128)), /*init output matrices or not*/ testing::Bool(), + Values(0.0), Values(cv::compile_args(CORE_CPU)))); INSTANTIATE_TEST_CASE_P(AbsDiffTestCPU, AbsDiffTest, @@ -213,6 +215,7 @@ INSTANTIATE_TEST_CASE_P(AddWeightedTestCPU, AddWeightedTest, cv::Size(128, 128)), Values( -1, CV_8U, CV_16U, CV_32F ), /*init output matrices or not*/ testing::Bool(), + Values(0.5000005), Values(cv::compile_args(CORE_CPU)))); INSTANTIATE_TEST_CASE_P(NormTestCPU, NormTest, @@ -221,6 +224,7 @@ INSTANTIATE_TEST_CASE_P(NormTestCPU, NormTest, Values(cv::Size(1280, 720), cv::Size(640, 480), cv::Size(128, 128)), + Values(0.0), Values(cv::compile_args(CORE_CPU))), opencv_test::PrintNormCoreParams()); @@ -271,25 +275,25 @@ INSTANTIATE_TEST_CASE_P(Split4TestCPU, Split4Test, Values(cv::compile_args(CORE_CPU)))); INSTANTIATE_TEST_CASE_P(ResizeTestCPU, ResizeTest, - Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ), + Combine(Values(AbsExact().to_compare_f()), + Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ), Values(cv::INTER_NEAREST, cv::INTER_LINEAR, cv::INTER_AREA), Values(cv::Size(1280, 720), cv::Size(640, 480), cv::Size(128, 128)), Values(cv::Size(64,64), cv::Size(30,30)), - Values(0.0), Values(cv::compile_args(CORE_CPU)))); INSTANTIATE_TEST_CASE_P(ResizeTestCPU, ResizeTestFxFy, - Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ), + Combine(Values(AbsExact().to_compare_f()), + Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ), Values(cv::INTER_NEAREST, cv::INTER_LINEAR, cv::INTER_AREA), Values(cv::Size(1280, 720), cv::Size(640, 480), cv::Size(128, 128)), Values(0.5, 0.1), Values(0.5, 0.1), - Values(0.0), Values(cv::compile_args(CORE_CPU)))); INSTANTIATE_TEST_CASE_P(Merge3TestCPU, Merge3Test, diff --git a/modules/gapi/test/cpu/gapi_core_tests_fluid.cpp b/modules/gapi/test/cpu/gapi_core_tests_fluid.cpp index 83bc6c12a2..ed281fa3af 100644 --- a/modules/gapi/test/cpu/gapi_core_tests_fluid.cpp +++ b/modules/gapi/test/cpu/gapi_core_tests_fluid.cpp @@ -14,6 +14,7 @@ namespace opencv_test #define CORE_FLUID cv::gapi::core::fluid::kernels() + // FIXME: Windows accuracy problems after recent update! INSTANTIATE_TEST_CASE_P(MathOpTestFluid, MathOpTest, Combine(Values(ADD, SUB, DIV, MUL), @@ -121,6 +122,7 @@ INSTANTIATE_TEST_CASE_P(AddWeightedTestFluid, AddWeightedTest, cv::Size(128, 128)), Values(-1, CV_8U, CV_32F), testing::Bool(), + Values(0.5000005), Values(cv::compile_args(CORE_FLUID)))); INSTANTIATE_TEST_CASE_P(LUTTestFluid, LUTTest, @@ -212,8 +214,10 @@ INSTANTIATE_TEST_CASE_P(InRangeTestFluid, InRangeTest, testing::Bool(), Values(cv::compile_args(CORE_FLUID)))); -INSTANTIATE_TEST_CASE_P(ResizeTestFluid, ResizeTest, - Combine(Values(CV_8UC3/*CV_8UC1, CV_16UC1, CV_16SC1*/), +INSTANTIATE_TEST_CASE_P( + ResizeTestFluid, ResizeTest, + Combine(Values(AbsExact().to_compare_f()), + Values(CV_8UC3/*CV_8UC1, CV_16UC1, CV_16SC1*/), Values(/*cv::INTER_NEAREST,*/ cv::INTER_LINEAR/*, cv::INTER_AREA*/), Values(cv::Size(1280, 720), cv::Size(640, 480), @@ -225,7 +229,6 @@ INSTANTIATE_TEST_CASE_P(ResizeTestFluid, ResizeTest, cv::Size(128, 128), cv::Size(64, 64), cv::Size(30, 30)), - Values(0.0), Values(cv::compile_args(CORE_FLUID)))); //---------------------------------------------------------------------- @@ -341,7 +344,9 @@ INSTANTIATE_TEST_CASE_P(SumTestCPU, SumTest, Values(cv::Size(1280, 720), cv::Size(640, 480), cv::Size(128, 128)), -/*init output matrices or not*/ testing::Bool())); +/*init output matrices or not*/ testing::Bool()) + Values(0.0), + ); INSTANTIATE_TEST_CASE_P(AbsDiffTestCPU, AbsDiffTest, Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1), @@ -371,6 +376,7 @@ INSTANTIATE_TEST_CASE_P(NormTestCPU, NormTest, Values(cv::Size(1280, 720), cv::Size(640, 480), cv::Size(128, 128))), + Values(0.0), opencv_test::PrintNormCoreParams()); INSTANTIATE_TEST_CASE_P(IntegralTestCPU, IntegralTest, diff --git a/modules/gapi/test/cpu/gapi_imgproc_tests_cpu.cpp b/modules/gapi/test/cpu/gapi_imgproc_tests_cpu.cpp index d5b3169f2f..ff70fd9006 100644 --- a/modules/gapi/test/cpu/gapi_imgproc_tests_cpu.cpp +++ b/modules/gapi/test/cpu/gapi_imgproc_tests_cpu.cpp @@ -15,26 +15,6 @@ namespace opencv_test { -class AbsExact : public Wrappable -{ -public: - AbsExact() {} - bool operator() (const cv::Mat& in1, const cv::Mat& in2) const { return cv::countNonZero(in1 != in2)==0; } -private: -}; - -class AbsTolerance : public Wrappable -{ -public: - AbsTolerance(double tol) : _tol(tol) {} - bool operator() (const cv::Mat& in1, const cv::Mat& in2) const - { - cv::Mat absDiff; cv::absdiff(in1, in2, absDiff); - return cv::countNonZero(absDiff > _tol) == 0; - } -private: - double _tol; -}; INSTANTIATE_TEST_CASE_P(Filter2DTestCPU, Filter2DTest, Combine(Values(AbsExact().to_compare_f()), @@ -49,7 +29,7 @@ INSTANTIATE_TEST_CASE_P(Filter2DTestCPU, Filter2DTest, Values(cv::compile_args(IMGPROC_CPU)))); INSTANTIATE_TEST_CASE_P(BoxFilterTestCPU, BoxFilterTest, - Combine(Values(AbsTolerance(1e-6).to_compare_f()), + Combine(Values(AbsTolerance(0).to_compare_f()), Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), Values(3,5), Values(cv::Size(1280, 720), diff --git a/modules/gapi/test/cpu/gapi_imgproc_tests_fluid.cpp b/modules/gapi/test/cpu/gapi_imgproc_tests_fluid.cpp index ffebac4f34..92a7b89f03 100644 --- a/modules/gapi/test/cpu/gapi_imgproc_tests_fluid.cpp +++ b/modules/gapi/test/cpu/gapi_imgproc_tests_fluid.cpp @@ -14,155 +14,36 @@ namespace opencv_test { -class AbsExactFluid : public Wrappable -{ -public: - AbsExactFluid() {} - bool operator() (const cv::Mat& in1, const cv::Mat& in2) const { return cv::countNonZero(in1 != in2) == 0; } -private: -}; - - -class AbsToleranceFluid : public Wrappable -{ -public: - AbsToleranceFluid(double tol) : _tol(tol) {} - bool operator() (const cv::Mat& in1, const cv::Mat& in2) const - { - cv::Mat absDiff; cv::absdiff(in1, in2, absDiff); - return cv::countNonZero(absDiff > _tol) == 0; - } -private: - double _tol; -}; - -class AbsToleranceSobelFluid : public Wrappable -{ -public: - AbsToleranceSobelFluid(double tol) : tolerance(tol) {} - bool operator() (const cv::Mat& in1, const cv::Mat& in2) const - { - cv::Mat diff, a1, a2, b, base; - cv::absdiff(in1, in2, diff); - a1 = cv::abs(in1); - a2 = cv::abs(in2); - cv::max(a1, a2, b); - cv::max(1, b, base); // base = max{1, |in1|, |in2|} - return cv::countNonZero(diff > tolerance*base) == 0; - } -private: - double tolerance; -}; - -class AbsTolerance32FFluid : public Wrappable -{ -public: - AbsTolerance32FFluid(double tol) : _tol(tol) {} - bool operator() (const cv::Mat& in1, const cv::Mat& in2) const - { - if (CV_MAT_DEPTH(in1.type()) == CV_32F) - return ((cv::countNonZero(cv::abs(in1 - in2) > (_tol)*cv::abs(in2))) ? false : true); - else - return ((cv::countNonZero(in1 != in2) <= (_tol * 100) * in2.total()) ? true : false); - } -private: - double _tol; -}; - -class AbsToleranceSepFilterFluid : public Wrappable -{ -public: - AbsToleranceSepFilterFluid(double tol) : _tol(tol) {} - bool operator() (const cv::Mat& in1, const cv::Mat& in2) const - { - return ((cv::countNonZero(cv::abs(in1 - in2) > (_tol)* cv::abs(in2)) <= 0.01 * in2.total()) ? true : false); - } -private: - double _tol; -}; - -class AbsToleranceGaussianBlurFluid : public Wrappable -{ -public: - AbsToleranceGaussianBlurFluid(double tol) : _tol(tol) {} - bool operator() (const cv::Mat& in1, const cv::Mat& in2) const - { - if (CV_MAT_DEPTH(in1.type()) == CV_32F || CV_MAT_DEPTH(in1.type()) == CV_64F) - { - return ((cv::countNonZero(cv::abs(in1 - in2) > (_tol)*cv::abs(in2))) ? false : true); - } - else - { - if (CV_MAT_DEPTH(in1.type()) == CV_8U) - { - bool a = (cv::countNonZero(cv::abs(in1 - in2) > 1) <= _tol * in2.total()); - return ((a == 1 ? 0 : 1) && ((cv::countNonZero(cv::abs(in1 - in2) > 2) <= 0) == 1 ? 0 : 1)) == 1 ? false : true; - } - else return cv::countNonZero(in1 != in2)==0; - } - } -private: - double _tol; -}; - -class AbsToleranceRGBBGRFluid : public Wrappable -{ -public: - AbsToleranceRGBBGRFluid(double tol) : _tol(tol) {} - bool operator() (const cv::Mat& in1, const cv::Mat& in2) const - { - bool a = (cv::countNonZero((in1 - in2) > 0) <= _tol * in2.total()); - return ((a == 1 ? 0 : 1) && ((cv::countNonZero((in1 - in2) > 1) <= 0) == 1 ? 0 : 1)) == 1 ? false : true; - } -private: - double _tol; -}; - -class ToleranceTripleFluid : public Wrappable -{ -public: - ToleranceTripleFluid(double tol1, double tol2, double tol3) : _tol1(tol1), _tol2(tol2), _tol3(tol3) {} - bool operator() (const cv::Mat& in1, const cv::Mat& in2) const - { - bool a = (cv::countNonZero((in1 - in2) > 0) <= _tol1 * in2.total()); - return (((a == 1 ? 0 : 1) && - ((cv::countNonZero((in1 - in2) > 1) <= _tol2 * in2.total()) == 1 ? 0 : 1) && - ((cv::countNonZero((in1 - in2) > 2) <= _tol3 * in2.total()) == 1 ? 0 : 1))) == 1 ? false : true; - } -private: - double _tol1, _tol2, _tol3; -}; - INSTANTIATE_TEST_CASE_P(RGB2GrayTestFluid, RGB2GrayTest, - Combine(Values(AbsToleranceRGBBGRFluid(0.001).to_compare_f()), + Combine(Values(ToleranceRGBBGR(0.001).to_compare_f()), Values(cv::Size(1280, 720), cv::Size(640, 480)), Values(true, false), Values(cv::compile_args(IMGPROC_FLUID)))); INSTANTIATE_TEST_CASE_P(BGR2GrayTestFluid, BGR2GrayTest, - Combine(Values(AbsToleranceRGBBGRFluid(0.001).to_compare_f()), + Combine(Values(ToleranceRGBBGR(0.001).to_compare_f()), Values(cv::Size(1280, 720), cv::Size(640, 480)), Values(true, false), Values(cv::compile_args(IMGPROC_FLUID)))); INSTANTIATE_TEST_CASE_P(RGB2YUVTestFluid, RGB2YUVTest, - Combine(Values(AbsToleranceRGBBGRFluid(0.15*3).to_compare_f()), + Combine(Values(ToleranceRGBBGR(0.15*3).to_compare_f()), Values(cv::Size(1280, 720), cv::Size(640, 480)), Values(true, false), Values(cv::compile_args(IMGPROC_FLUID)))); INSTANTIATE_TEST_CASE_P(YUV2RGBTestFluid, YUV2RGBTest, - Combine(Values(ToleranceTripleFluid(0.25 * 3, 0.01 * 3, 1e-5 * 3).to_compare_f()), + Combine(Values(ToleranceTriple(0.25 * 3, 0.01 * 3, 1e-5 * 3).to_compare_f()), Values(cv::Size(1280, 720), cv::Size(640, 480)), Values(true, false), Values(cv::compile_args(IMGPROC_FLUID)))); INSTANTIATE_TEST_CASE_P(RGB2LabTestFluid, RGB2LabTest, - Combine(Values(ToleranceTripleFluid(0.25 * 3, 0.0, 1e-5 * 3).to_compare_f()), + Combine(Values(ToleranceTriple(0.25 * 3, 0.0, 1e-5 * 3).to_compare_f()), Values(cv::Size(1280, 720), cv::Size(640, 480)), Values(true, false), @@ -170,14 +51,14 @@ INSTANTIATE_TEST_CASE_P(RGB2LabTestFluid, RGB2LabTest, // FIXME: Not supported by Fluid yet (no kernel implemented) INSTANTIATE_TEST_CASE_P(BGR2LUVTestFluid, BGR2LUVTest, - Combine(Values(ToleranceTripleFluid(0.25 * 3, 0.01 * 3, 0.0001 * 3).to_compare_f()), + Combine(Values(ToleranceTriple(0.25 * 3, 0.01 * 3, 0.0001 * 3).to_compare_f()), Values(cv::Size(1280, 720), cv::Size(640, 480)), Values(true, false), Values(cv::compile_args(IMGPROC_FLUID)))); INSTANTIATE_TEST_CASE_P(blurTestFluid, BlurTest, - Combine(Values(AbsToleranceFluid(0.0).to_compare_f()), + Combine(Values(AbsTolerance(0.0).to_compare_f()), Values(CV_8UC1, CV_16UC1, CV_16SC1), Values(3), // add kernel size=5 when implementation is ready Values(cv::Size(1280, 720), @@ -187,7 +68,7 @@ INSTANTIATE_TEST_CASE_P(blurTestFluid, BlurTest, Values(cv::compile_args(IMGPROC_FLUID)))); INSTANTIATE_TEST_CASE_P(gaussBlurTestFluid, GaussianBlurTest, - Combine(Values(AbsToleranceGaussianBlurFluid(1e-6).to_compare_f()), + Combine(Values(AbsToleranceGaussianBlur_Float_Int(1e-6, 1e-6).to_compare_f()), Values(CV_8UC1, CV_16UC1, CV_16SC1), Values(3), // add kernel size=5 when implementation is ready Values(cv::Size(1280, 720), @@ -196,7 +77,7 @@ INSTANTIATE_TEST_CASE_P(gaussBlurTestFluid, GaussianBlurTest, Values(cv::compile_args(IMGPROC_FLUID)))); INSTANTIATE_TEST_CASE_P(medianBlurTestFluid, MedianBlurTest, - Combine(Values(AbsExactFluid().to_compare_f()), + Combine(Values(AbsExact().to_compare_f()), Values(CV_8UC1, CV_16UC1, CV_16SC1), Values(3), // add kernel size=5 when implementation is ready Values(cv::Size(1280, 720), @@ -205,7 +86,7 @@ INSTANTIATE_TEST_CASE_P(medianBlurTestFluid, MedianBlurTest, Values(cv::compile_args(IMGPROC_FLUID)))); INSTANTIATE_TEST_CASE_P(erodeTestFluid, ErodeTest, - Combine(Values(AbsExactFluid().to_compare_f()), + Combine(Values(AbsExact().to_compare_f()), Values(CV_8UC1, CV_16UC1, CV_16SC1), Values(3), // add kernel size=5 when implementation is ready Values(cv::Size(1280, 720), @@ -217,7 +98,7 @@ INSTANTIATE_TEST_CASE_P(erodeTestFluid, ErodeTest, Values(cv::compile_args(IMGPROC_FLUID)))); INSTANTIATE_TEST_CASE_P(dilateTestFluid, DilateTest, - Combine(Values(AbsExactFluid().to_compare_f()), + Combine(Values(AbsExact().to_compare_f()), Values(CV_8UC1, CV_16UC1, CV_16SC1), Values(3), // add kernel size=5 when implementation is ready Values(cv::Size(1280, 720), @@ -229,7 +110,7 @@ INSTANTIATE_TEST_CASE_P(dilateTestFluid, DilateTest, Values(cv::compile_args(IMGPROC_FLUID)))); INSTANTIATE_TEST_CASE_P(SobelTestFluid, SobelTest, - Combine(Values(AbsExactFluid().to_compare_f()), + Combine(Values(AbsExact().to_compare_f()), Values(CV_8UC1, CV_16UC1, CV_16SC1), Values(3), // add kernel size=5 when implementation is ready Values(cv::Size(1280, 720), @@ -241,7 +122,7 @@ INSTANTIATE_TEST_CASE_P(SobelTestFluid, SobelTest, Values(cv::compile_args(IMGPROC_FLUID)))); INSTANTIATE_TEST_CASE_P(SobelTestFluid32F, SobelTest, - Combine(Values(AbsToleranceSobelFluid(1e-3).to_compare_f()), + Combine(Values(AbsToleranceSobel(1e-3).to_compare_f()), Values(CV_32FC1), Values(3), // add kernel size=5 when implementation is ready Values(cv::Size(1280, 720), @@ -253,7 +134,7 @@ INSTANTIATE_TEST_CASE_P(SobelTestFluid32F, SobelTest, Values(cv::compile_args(IMGPROC_FLUID)))); INSTANTIATE_TEST_CASE_P(boxFilterTestFluid32, BoxFilterTest, - Combine(Values(AbsTolerance32FFluid(1e-6).to_compare_f()), + Combine(Values(AbsTolerance_Float_Int(1e-6, 1e-4).to_compare_f()), Values(CV_8UC1, CV_16UC1, CV_16SC1), Values(3), // add kernel size=5 when implementation is ready Values(cv::Size(1280, 720), @@ -264,7 +145,7 @@ INSTANTIATE_TEST_CASE_P(boxFilterTestFluid32, BoxFilterTest, Values(cv::compile_args(IMGPROC_FLUID)))); INSTANTIATE_TEST_CASE_P(sepFilterTestFluid, SepFilterTest, - Combine(Values(AbsToleranceSepFilterFluid(1e-5f).to_compare_f()), + Combine(Values(AbsToleranceSepFilter(1e-5f).to_compare_f()), Values(CV_32FC1), Values(3), // add kernel size=5 when implementation is ready Values(cv::Size(1280, 720), @@ -274,7 +155,7 @@ INSTANTIATE_TEST_CASE_P(sepFilterTestFluid, SepFilterTest, Values(cv::compile_args(IMGPROC_FLUID)))); INSTANTIATE_TEST_CASE_P(filter2DTestFluid, Filter2DTest, - Combine(Values(AbsTolerance32FFluid(1e-6).to_compare_f()), + Combine(Values(AbsTolerance_Float_Int(1e-6, 1e-4).to_compare_f()), Values(CV_8UC1, CV_16UC1, CV_16SC1), Values(3), // add kernel size=4,5,7 when implementation ready Values(cv::Size(1280, 720), diff --git a/modules/gapi/test/cpu/gapi_operators_tests_cpu.cpp b/modules/gapi/test/cpu/gapi_operators_tests_cpu.cpp index 92246783db..8897d01b15 100644 --- a/modules/gapi/test/cpu/gapi_operators_tests_cpu.cpp +++ b/modules/gapi/test/cpu/gapi_operators_tests_cpu.cpp @@ -13,55 +13,61 @@ namespace opencv_test { - // FIXME: CPU test runs are disabled since Fluid is an exclusive plugin now! - INSTANTIATE_TEST_CASE_P(MathOperatorTestCPU, MathOperatorMatMatTest, - Combine(Values( opPlusM, opMinusM, opDivM, - opGreater, opLess, opGreaterEq, opLessEq, opEq, opNotEq), + + +// FIXME: CPU test runs are disabled since Fluid is an exclusive plugin now! +INSTANTIATE_TEST_CASE_P(MathOperatorTestCPU, MathOperatorMatMatTest, + Combine(Values(AbsExact().to_compare_f()), + Values( opPlusM, opMinusM, opDivM, + opGreater, opLess, opGreaterEq, opLessEq, opEq, opNotEq), + Values(CV_8UC1, CV_16SC1, CV_32FC1), + Values(cv::Size(1280, 720), + cv::Size(640, 480), + cv::Size(128, 128)), + Values(-1, CV_8U, CV_32F), +/*init output matrices or not*/ testing::Bool(), + Values(cv::compile_args(CORE_CPU)))); + +INSTANTIATE_TEST_CASE_P(MathOperatorTestCPU, MathOperatorMatScalarTest, + Combine(Values(AbsExact().to_compare_f()), + Values( opPlus, opPlusR, opMinus, opMinusR, opMul, opMulR, opDiv, opDivR, + opGT, opLT, opGE, opLE, opEQ, opNE, + opGTR, opLTR, opGER, opLER, opEQR, opNER), Values(CV_8UC1, CV_16SC1, CV_32FC1), + Values(cv::Size(1280, 720), + cv::Size(640, 480), + cv::Size(128, 128)), + Values(-1, CV_8U, CV_32F), +/*init output matrices or not*/ testing::Bool(), + Values(cv::compile_args(CORE_CPU)))); + +INSTANTIATE_TEST_CASE_P(BitwiseOperatorTestCPU, MathOperatorMatMatTest, + Combine(Values(AbsExact().to_compare_f()), + Values( opAnd, opOr, opXor ), + Values(CV_8UC1, CV_16UC1, CV_16SC1), Values(cv::Size(1280, 720), cv::Size(640, 480), cv::Size(128, 128)), - Values(-1, CV_8U, CV_32F), - /*init output matrices or not*/ testing::Bool(), + Values(-1), +/*init output matrices or not*/ testing::Bool(), Values(cv::compile_args(CORE_CPU)))); - INSTANTIATE_TEST_CASE_P(MathOperatorTestCPU, MathOperatorMatScalarTest, - Combine(Values( opPlus, opPlusR, opMinus, opMinusR, opMul, opMulR, opDiv, opDivR, - opGT, opLT, opGE, opLE, opEQ, opNE, - opGTR, opLTR, opGER, opLER, opEQR, opNER), - Values(CV_8UC1, CV_16SC1, CV_32FC1), - Values(cv::Size(1280, 720), - cv::Size(640, 480), - cv::Size(128, 128)), - Values(-1, CV_8U, CV_32F), - /*init output matrices or not*/ testing::Bool(), - Values(cv::compile_args(CORE_CPU)))); - - INSTANTIATE_TEST_CASE_P(BitwiseOperatorTestCPU, MathOperatorMatMatTest, - Combine(Values( opAnd, opOr, opXor ), - Values(CV_8UC1, CV_16UC1, CV_16SC1), - Values(cv::Size(1280, 720), +INSTANTIATE_TEST_CASE_P(BitwiseOperatorTestCPU, MathOperatorMatScalarTest, + Combine(Values(AbsExact().to_compare_f()), + Values( opAND, opOR, opXOR, opANDR, opORR, opXORR ), + Values(CV_8UC1, CV_16UC1, CV_16SC1), + Values(cv::Size(1280, 720), cv::Size(640, 480), cv::Size(128, 128)), - Values(-1), - /*init output matrices or not*/ testing::Bool(), - Values(cv::compile_args(CORE_CPU)))); + Values(-1), +/*init output matrices or not*/ testing::Bool(), + Values(cv::compile_args(CORE_CPU)))); - INSTANTIATE_TEST_CASE_P(BitwiseOperatorTestCPU, MathOperatorMatScalarTest, - Combine(Values( opAND, opOR, opXOR, opANDR, opORR, opXORR ), - Values(CV_8UC1, CV_16UC1, CV_16SC1), - Values(cv::Size(1280, 720), - cv::Size(640, 480), - cv::Size(128, 128)), - Values(-1), - /*init output matrices or not*/ testing::Bool(), - Values(cv::compile_args(CORE_CPU)))); - - INSTANTIATE_TEST_CASE_P(BitwiseNotOperatorTestCPU, NotOperatorTest, - Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1), - Values(cv::Size(1280, 720), - cv::Size(640, 480), - cv::Size(128, 128)), - /*init output matrices or not*/ testing::Bool(), - Values(cv::compile_args(CORE_CPU)))); +INSTANTIATE_TEST_CASE_P(BitwiseNotOperatorTestCPU, NotOperatorTest, + Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1), + Values(cv::Size(1280, 720), + cv::Size(640, 480), + cv::Size(128, 128)), +/*init output matrices or not*/ testing::Bool(), + Values(cv::compile_args(CORE_CPU)))); } diff --git a/modules/gapi/test/cpu/gapi_operators_tests_fluid.cpp b/modules/gapi/test/cpu/gapi_operators_tests_fluid.cpp index d6f23ef04a..7b98af40b0 100644 --- a/modules/gapi/test/cpu/gapi_operators_tests_fluid.cpp +++ b/modules/gapi/test/cpu/gapi_operators_tests_fluid.cpp @@ -13,56 +13,61 @@ namespace opencv_test { - INSTANTIATE_TEST_CASE_P(MathOperatorTestFluid, MathOperatorMatMatTest, - Combine(Values( opPlusM, opMinusM, opDivM, - opGreater, opLess, opGreaterEq, opLessEq, opEq, opNotEq), - Values(CV_8UC1, CV_16SC1, CV_32FC1), - Values(cv::Size(1280, 720), - cv::Size(640, 480), - cv::Size(128, 128)), - Values(-1, CV_8U, CV_32F), - /*init output matrices or not*/ testing::Bool(), - Values(cv::compile_args(CORE_FLUID)))); - //FIXME: Some Mat/Scalar Fluid kernels are not there yet! - INSTANTIATE_TEST_CASE_P(DISABLED_MathOperatorTestFluid, MathOperatorMatScalarTest, - Combine(Values( opPlus, opPlusR, opMinus, opMinusR, opMul, opMulR, opDiv, opDivR, - opGT, opLT, opGE, opLE, opEQ, opNE, - opGTR, opLTR, opGER, opLER, opEQR, opNER), - Values(CV_8UC1, CV_16SC1, CV_32FC1), - Values(cv::Size(1280, 720), - cv::Size(640, 480), - cv::Size(128, 128)), - Values(-1, CV_8U, CV_32F), - /*init output matrices or not*/ testing::Bool(), - Values(cv::compile_args(CORE_FLUID)))); +INSTANTIATE_TEST_CASE_P(MathOperatorTestFluid, MathOperatorMatMatTest, + Combine(Values(AbsExact().to_compare_f()), + Values( opPlusM, opMinusM, opDivM, + opGreater, opLess, opGreaterEq, opLessEq, opEq, opNotEq), + Values(CV_8UC1, CV_16SC1, CV_32FC1), + Values(cv::Size(1280, 720), + cv::Size(640, 480), + cv::Size(128, 128)), + Values(-1, CV_8U, CV_32F), +/*init output matrices or not*/ testing::Bool(), + Values(cv::compile_args(CORE_FLUID)))); - INSTANTIATE_TEST_CASE_P(BitwiseOperatorTestFluid, MathOperatorMatMatTest, - Combine(Values( opAnd, opOr, opXor ), - Values(CV_8UC1, CV_16UC1, CV_16SC1), - Values(cv::Size(1280, 720), - cv::Size(640, 480), - cv::Size(128, 128)), - Values(-1), - /*init output matrices or not*/ testing::Bool(), - Values(cv::compile_args(CORE_FLUID)))); - - //FIXME: Some Mat/Scalar Fluid kernels are not there yet! - INSTANTIATE_TEST_CASE_P(DISABLED_BitwiseOperatorTestFluid, MathOperatorMatScalarTest, - Combine(Values( opAND, opOR, opXOR, opANDR, opORR, opXORR ), - Values(CV_8UC1, CV_16UC1, CV_16SC1), - Values(cv::Size(1280, 720), - cv::Size(640, 480), - cv::Size(128, 128)), - Values(-1), - /*init output matrices or not*/ testing::Bool(), - Values(cv::compile_args(CORE_FLUID)))); - - INSTANTIATE_TEST_CASE_P(BitwiseNotOperatorTestFluid, NotOperatorTest, - Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1), +//FIXME: Some Mat/Scalar Fluid kernels are not there yet! +INSTANTIATE_TEST_CASE_P(DISABLED_MathOperatorTestFluid, MathOperatorMatScalarTest, + Combine(Values(AbsExact().to_compare_f()), + Values( opPlus, opPlusR, opMinus, opMinusR, opMul, opMulR, opDiv, opDivR, + opGT, opLT, opGE, opLE, opEQ, opNE, + opGTR, opLTR, opGER, opLER, opEQR, opNER), + Values(CV_8UC1, CV_16SC1, CV_32FC1), Values(cv::Size(1280, 720), cv::Size(640, 480), cv::Size(128, 128)), - /*init output matrices or not*/ testing::Bool(), - Values(cv::compile_args(CORE_FLUID)))); + Values(-1, CV_8U, CV_32F), +/*init output matrices or not*/ testing::Bool(), + Values(cv::compile_args(CORE_FLUID)))); + +INSTANTIATE_TEST_CASE_P(BitwiseOperatorTestFluid, MathOperatorMatMatTest, + Combine(Values(AbsExact().to_compare_f()), + Values( opAnd, opOr, opXor ), + Values(CV_8UC1, CV_16UC1, CV_16SC1), + Values(cv::Size(1280, 720), + cv::Size(640, 480), + cv::Size(128, 128)), + Values(-1), +/*init output matrices or not*/ testing::Bool(), + Values(cv::compile_args(CORE_FLUID)))); + +//FIXME: Some Mat/Scalar Fluid kernels are not there yet! +INSTANTIATE_TEST_CASE_P(DISABLED_BitwiseOperatorTestFluid, MathOperatorMatScalarTest, + Combine(Values(AbsExact().to_compare_f()), + Values( opAND, opOR, opXOR, opANDR, opORR, opXORR ), + Values(CV_8UC1, CV_16UC1, CV_16SC1), + Values(cv::Size(1280, 720), + cv::Size(640, 480), + cv::Size(128, 128)), + Values(-1), +/*init output matrices or not*/ testing::Bool(), + Values(cv::compile_args(CORE_FLUID)))); + +INSTANTIATE_TEST_CASE_P(BitwiseNotOperatorTestFluid, NotOperatorTest, + Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1), + Values(cv::Size(1280, 720), + cv::Size(640, 480), + cv::Size(128, 128)), +/*init output matrices or not*/ testing::Bool(), + Values(cv::compile_args(CORE_FLUID)))); } diff --git a/modules/gapi/test/gpu/gapi_core_tests_gpu.cpp b/modules/gapi/test/gpu/gapi_core_tests_gpu.cpp new file mode 100644 index 0000000000..077df783e9 --- /dev/null +++ b/modules/gapi/test/gpu/gapi_core_tests_gpu.cpp @@ -0,0 +1,395 @@ +// This file is part of OpenCV project. +// It is subject to the license terms in the LICENSE file found in the top-level directory +// of this distribution and at http://opencv.org/license.html. +// +// Copyright (C) 2018 Intel Corporation + + +#include "../test_precomp.hpp" +#include "../common/gapi_core_tests.hpp" +#include "opencv2/gapi/gpu/core.hpp" + +#define CORE_GPU cv::gapi::core::gpu::kernels() + +namespace opencv_test +{ + +// FIXME: Wut? See MulTestGPU/MathOpTest below (duplicate?) +INSTANTIATE_TEST_CASE_P(AddTestGPU, MathOpTest, + Combine(Values(ADD, MUL), + testing::Bool(), + Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ), + Values(1.0), + Values(cv::Size(1280, 720), + cv::Size(640, 480), + cv::Size(128, 128)), + Values( -1, CV_8U, CV_16U, CV_32F ), + /*init output matrices or not*/ testing::Bool(), + Values(false), + Values(cv::compile_args(CORE_GPU))), + opencv_test::PrintMathOpCoreParams()); + +INSTANTIATE_TEST_CASE_P(MulTestGPU, MathOpTest, + Combine(Values(MUL), + testing::Bool(), + Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ), + Values(1.0, 0.5, 2.0), + Values(cv::Size(1280, 720), + cv::Size(640, 480), + cv::Size(128, 128)), + Values( -1, CV_8U, CV_16U, CV_32F ), + /*init output matrices or not*/ testing::Bool(), + Values(false), + Values(cv::compile_args(CORE_GPU))), + opencv_test::PrintMathOpCoreParams()); + +INSTANTIATE_TEST_CASE_P(SubTestGPU, MathOpTest, + Combine(Values(SUB), + testing::Bool(), + Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ), + Values (1.0), + Values(cv::Size(1280, 720), + cv::Size(640, 480), + cv::Size(128, 128)), + Values( -1, CV_8U, CV_16U, CV_32F ), + /*init output matrices or not*/ testing::Bool(), + testing::Bool(), + Values(cv::compile_args(CORE_GPU))), + opencv_test::PrintMathOpCoreParams()); + +INSTANTIATE_TEST_CASE_P(DivTestGPU, MathOpTest, + Combine(Values(DIV), + testing::Bool(), + Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ), + Values (1.0, 0.5, 2.0), + Values(cv::Size(1280, 720), + cv::Size(640, 480), + cv::Size(128, 128)), + Values( -1, CV_8U, CV_16U, CV_32F ), + /*init output matrices or not*/ testing::Bool(), + testing::Bool(), + Values(cv::compile_args(CORE_GPU))), + opencv_test::PrintMathOpCoreParams()); + +INSTANTIATE_TEST_CASE_P(MulTestGPU, MulDoubleTest, + Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ), + Values(cv::Size(1280, 720), + cv::Size(640, 480), + cv::Size(128, 128)), + Values( -1, CV_8U, CV_16U, CV_32F ), + /*init output matrices or not*/ testing::Bool(), + Values(cv::compile_args(CORE_GPU)))); + +INSTANTIATE_TEST_CASE_P(DivTestGPU, DivTest, + Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ), + Values(cv::Size(1280, 720), + cv::Size(640, 480), + cv::Size(128, 128)), + Values( -1, CV_8U, CV_16U, CV_32F ), + /*init output matrices or not*/ testing::Bool(), + Values(cv::compile_args(CORE_GPU)))); + +INSTANTIATE_TEST_CASE_P(DivCTestGPU, DivCTest, + Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ), + Values(cv::Size(1280, 720), + cv::Size(640, 480), + cv::Size(128, 128)), + Values( -1, CV_8U, CV_16U, CV_32F ), + /*init output matrices or not*/ testing::Bool(), + Values(cv::compile_args(CORE_GPU)))); + +INSTANTIATE_TEST_CASE_P(MeanTestGPU, MeanTest, + Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ), + Values(cv::Size(1280, 720), + cv::Size(640, 480), + cv::Size(128, 128)), + /*init output matrices or not*/ testing::Bool(), + Values(cv::compile_args(CORE_GPU)))); + +//TODO: mask test doesn't work +#if 0 +INSTANTIATE_TEST_CASE_P(MaskTestGPU, MaskTest, + Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1), + Values(cv::Size(1280, 720), + cv::Size(640, 480), + cv::Size(128, 128)), +/*init output matrices or not*/ testing::Bool(), + Values(cv::compile_args(CORE_GPU)))); +#endif + +INSTANTIATE_TEST_CASE_P(SelectTestGPU, SelectTest, + Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ), + Values(cv::Size(1280, 720), + cv::Size(640, 480), + cv::Size(128, 128)), +/*init output matrices or not*/ testing::Bool(), + Values(cv::compile_args(CORE_GPU)))); + +INSTANTIATE_TEST_CASE_P(Polar2CartGPU, Polar2CartTest, + Combine(Values(cv::Size(1280, 720), + cv::Size(640, 480), + cv::Size(128, 128)), +/*init output matrices or not*/ testing::Bool(), + Values(cv::compile_args(CORE_GPU)))); + +INSTANTIATE_TEST_CASE_P(Cart2PolarGPU, Cart2PolarTest, + Combine(Values(cv::Size(1280, 720), + cv::Size(640, 480), + cv::Size(128, 128)), +/*init output matrices or not*/ testing::Bool(), + Values(cv::compile_args(CORE_GPU)))); + +INSTANTIATE_TEST_CASE_P(CompareTestGPU, CmpTest, + Combine(Values(CMP_EQ, CMP_GE, CMP_NE, CMP_GT, CMP_LT, CMP_LE), + testing::Bool(), + Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ), + Values(cv::Size(1280, 720), + cv::Size(640, 480), + cv::Size(128, 128)), +/*init output matrices or not*/ testing::Bool(), + Values(cv::compile_args(CORE_GPU))), + opencv_test::PrintCmpCoreParams()); + +INSTANTIATE_TEST_CASE_P(BitwiseTestGPU, BitwiseTest, + Combine(Values(AND, OR, XOR), + Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1), + Values(cv::Size(1280, 720), + cv::Size(640, 480), + cv::Size(128, 128)), +/*init output matrices or not*/ testing::Bool(), + Values(cv::compile_args(CORE_GPU))), + opencv_test::PrintBWCoreParams()); + +INSTANTIATE_TEST_CASE_P(BitwiseNotTestGPU, NotTest, + Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ), + Values(cv::Size(1280, 720), + cv::Size(640, 480), + cv::Size(128, 128)), + /*init output matrices or not*/ testing::Bool(), + Values(cv::compile_args(CORE_GPU)))); + +INSTANTIATE_TEST_CASE_P(MinTestGPU, MinTest, + Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ), + Values(cv::Size(1280, 720), + cv::Size(640, 480), + cv::Size(128, 128)), +/*init output matrices or not*/ testing::Bool(), + Values(cv::compile_args(CORE_GPU)))); + +INSTANTIATE_TEST_CASE_P(MaxTestGPU, MaxTest, + Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ), + Values(cv::Size(1280, 720), + cv::Size(640, 480), + cv::Size(128, 128)), +/*init output matrices or not*/ testing::Bool(), + Values(cv::compile_args(CORE_GPU)))); + +INSTANTIATE_TEST_CASE_P(SumTestGPU, SumTest, + Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ), + Values(cv::Size(1280, 720), + cv::Size(640, 480), + cv::Size(128, 128)), +/*init output matrices or not*/ testing::Bool(), + Values(0.5), //Values(0.04), //TODO: too relaxed? + Values(cv::compile_args(CORE_GPU)))); + +INSTANTIATE_TEST_CASE_P(AbsDiffTestGPU, AbsDiffTest, + Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ), + Values(cv::Size(1280, 720), + cv::Size(640, 480), + cv::Size(128, 128)), +/*init output matrices or not*/ testing::Bool(), + Values(cv::compile_args(CORE_GPU)))); + +INSTANTIATE_TEST_CASE_P(AbsDiffCTestGPU, AbsDiffCTest, + Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ), + Values(cv::Size(1280, 720), + cv::Size(640, 480), + cv::Size(128, 128)), +/*init output matrices or not*/ testing::Bool(), + Values(cv::compile_args(CORE_GPU)))); + +// FIXME: Comparison introduced by YL doesn't work with C3 +INSTANTIATE_TEST_CASE_P(AddWeightedTestGPU, AddWeightedTest, + Combine(Values( CV_8UC1/*, CV_8UC3*/, CV_16UC1, CV_16SC1, CV_32FC1 ), + Values(cv::Size(1280, 720), + cv::Size(640, 480), + cv::Size(128, 128)), + Values( -1, CV_8U, CV_16U, CV_32F ), +/*init output matrices or not*/ testing::Bool(), + Values(0.50005), + Values(cv::compile_args(CORE_GPU)))); + +INSTANTIATE_TEST_CASE_P(NormTestGPU, NormTest, + Combine(Values(NORM_INF, NORM_L1, NORM_L2), + Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ), + Values(cv::Size(1280, 720), + cv::Size(640, 480), + cv::Size(128, 128)), + Values(0.04), //TODO: too relaxed? + Values(cv::compile_args(CORE_GPU))), + opencv_test::PrintNormCoreParams()); + +INSTANTIATE_TEST_CASE_P(IntegralTestGPU, IntegralTest, + Combine(Values( CV_8UC1, CV_16UC1, CV_16SC1, CV_32FC1 ), + Values(cv::Size(1280, 720), + cv::Size(640, 480), + cv::Size(128, 128)), + Values(cv::compile_args(CORE_GPU)))); + +INSTANTIATE_TEST_CASE_P(ThresholdTestGPU, ThresholdTest, + Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ), + Values(cv::Size(1280, 720), + cv::Size(640, 480), + cv::Size(128, 128)), + Values(cv::THRESH_BINARY, cv::THRESH_BINARY_INV, cv::THRESH_TRUNC, cv::THRESH_TOZERO, cv::THRESH_TOZERO_INV), +/*init output matrices or not*/ testing::Bool(), + Values(cv::compile_args(CORE_GPU)))); + +INSTANTIATE_TEST_CASE_P(ThresholdTestGPU, ThresholdOTTest, + Combine(Values(CV_8UC1), + Values(cv::Size(1280, 720), + cv::Size(640, 480), + cv::Size(128, 128)), + Values(cv::THRESH_OTSU, cv::THRESH_TRIANGLE), +/*init output matrices or not*/ testing::Bool(), + Values(cv::compile_args(CORE_GPU)))); + + +INSTANTIATE_TEST_CASE_P(InRangeTestGPU, InRangeTest, + Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1), + Values(cv::Size(1280, 720), + cv::Size(640, 480), + cv::Size(128, 128)), +/*init output matrices or not*/ testing::Bool(), + Values(cv::compile_args(CORE_GPU)))); + +INSTANTIATE_TEST_CASE_P(Split3TestGPU, Split3Test, + Combine(Values(cv::Size(1280, 720), + cv::Size(640, 480), + cv::Size(128, 128)), + Values(cv::compile_args(CORE_GPU)))); + +INSTANTIATE_TEST_CASE_P(Split4TestGPU, Split4Test, + Combine(Values(cv::Size(1280, 720), + cv::Size(640, 480), + cv::Size(128, 128)), + Values(cv::compile_args(CORE_GPU)))); + +INSTANTIATE_TEST_CASE_P(ResizeTestGPU, ResizeTest, + Combine(Values(AbsTolerance_Float_Int(1e-3, 1e-0).to_compare_f()), //TODO: too relaxed? + Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ), + Values(cv::INTER_NEAREST, cv::INTER_LINEAR, cv::INTER_AREA), + Values(cv::Size(1280, 720), + cv::Size(640, 480), + cv::Size(128, 128)), + Values(cv::Size(64,64), + cv::Size(30,30)), + Values(cv::compile_args(CORE_GPU)))); + +INSTANTIATE_TEST_CASE_P(ResizeTestGPU, ResizeTestFxFy, + Combine(Values(AbsTolerance_Float_Int(1e-1, 1e-0).to_compare_f()), //TODO: too relaxed? + Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ), + Values(cv::INTER_NEAREST, cv::INTER_LINEAR, cv::INTER_AREA), + Values(cv::Size(1280, 720), + cv::Size(640, 480), + cv::Size(128, 128)), + Values(0.5, 0.1), + Values(0.5, 0.1), + Values(cv::compile_args(CORE_GPU)))); + +INSTANTIATE_TEST_CASE_P(Merge3TestGPU, Merge3Test, + Combine(Values(cv::Size(1280, 720), + cv::Size(640, 480), + cv::Size(128, 128)), + Values(cv::compile_args(CORE_GPU)))); + +INSTANTIATE_TEST_CASE_P(Merge4TestGPU, Merge4Test, + Combine(Values(cv::Size(1280, 720), + cv::Size(640, 480), + cv::Size(128, 128)), + Values(cv::compile_args(CORE_GPU)))); + +INSTANTIATE_TEST_CASE_P(RemapTestGPU, RemapTest, + Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ), + Values(cv::Size(1280, 720), + cv::Size(640, 480), + cv::Size(128, 128)), +/*init output matrices or not*/ testing::Bool(), + Values(cv::compile_args(CORE_GPU)))); + +INSTANTIATE_TEST_CASE_P(FlipTestGPU, FlipTest, + Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ), + Values(0,1,-1), + Values(cv::Size(1280, 720), + cv::Size(640, 480), + cv::Size(128, 128)), +/*init output matrices or not*/ testing::Bool(), + Values(cv::compile_args(CORE_GPU)))); + +INSTANTIATE_TEST_CASE_P(CropTestGPU, CropTest, + Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ), + Values(cv::Rect(10, 8, 20, 35), cv::Rect(4, 10, 37, 50)), + Values(cv::Size(1280, 720), + cv::Size(640, 480), + cv::Size(128, 128)), +/*init output matrices or not*/ testing::Bool(), + Values(cv::compile_args(CORE_GPU)))); + +INSTANTIATE_TEST_CASE_P(LUTTestGPU, LUTTest, + Combine(Values(CV_8UC1, CV_8UC3), + Values(CV_8UC1), + Values(cv::Size(1280, 720), + cv::Size(640, 480), + cv::Size(128, 128)), +/*init output matrices or not*/ testing::Bool(), + Values(cv::compile_args(CORE_GPU)))); + +INSTANTIATE_TEST_CASE_P(LUTTestCustomGPU, LUTTest, + Combine(Values(CV_8UC3), + Values(CV_8UC3), + Values(cv::Size(1280, 720), + cv::Size(640, 480), + cv::Size(128, 128)), +/*init output matrices or not*/ testing::Bool(), + Values(cv::compile_args(CORE_GPU)))); + +INSTANTIATE_TEST_CASE_P(ConvertToGPU, ConvertToTest, + Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ), + Values(CV_8U, CV_16U, CV_16S, CV_32F), + Values(cv::Size(1280, 720), + cv::Size(640, 480), + cv::Size(128, 128)), + Values(cv::compile_args(CORE_GPU)))); + +INSTANTIATE_TEST_CASE_P(ConcatHorTestGPU, ConcatHorTest, + Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ), + Values(cv::Size(1280, 720), + cv::Size(640, 480), + cv::Size(128, 128)), + Values(cv::compile_args(CORE_GPU)))); + +INSTANTIATE_TEST_CASE_P(ConcatVertTestGPU, ConcatVertTest, + Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ), + Values(cv::Size(1280, 720), + cv::Size(640, 480), + cv::Size(128, 128)), + Values(cv::compile_args(CORE_GPU)))); + +//TODO: fix this backend to allow ConcatVertVec ConcatHorVec +#if 0 +INSTANTIATE_TEST_CASE_P(ConcatVertVecTestGPU, ConcatVertVecTest, + Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ), + Values(cv::Size(1280, 720), + cv::Size(640, 480), + cv::Size(128, 128)), + Values(cv::compile_args(CORE_GPU)))); + +INSTANTIATE_TEST_CASE_P(ConcatHorVecTestGPU, ConcatHorVecTest, + Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ), + Values(cv::Size(1280, 720), + cv::Size(640, 480), + cv::Size(128, 128)), + Values(cv::compile_args(CORE_GPU)))); +#endif +} diff --git a/modules/gapi/test/gpu/gapi_imgproc_tests_gpu.cpp b/modules/gapi/test/gpu/gapi_imgproc_tests_gpu.cpp new file mode 100644 index 0000000000..6177f55f8d --- /dev/null +++ b/modules/gapi/test/gpu/gapi_imgproc_tests_gpu.cpp @@ -0,0 +1,227 @@ +// This file is part of OpenCV project. +// It is subject to the license terms in the LICENSE file found in the top-level directory +// of this distribution and at http://opencv.org/license.html. +// +// Copyright (C) 2018 Intel Corporation + + +#include "../test_precomp.hpp" + +#include "../common/gapi_imgproc_tests.hpp" +#include "opencv2/gapi/gpu/imgproc.hpp" + +#define IMGPROC_GPU cv::gapi::imgproc::gpu::kernels() + +namespace opencv_test +{ + + +INSTANTIATE_TEST_CASE_P(Filter2DTestGPU, Filter2DTest, + Combine(Values(AbsTolerance_Float_Int(1e-5, 1e-3).to_compare_f()), + Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), + Values(3, 4, 5, 7), + Values(cv::Size(1280, 720), + cv::Size(640, 480), + cv::Size(128, 128)), + Values(cv::BORDER_DEFAULT), + Values(-1, CV_32F), +/*init output matrices or not*/ testing::Bool(), + Values(cv::compile_args(IMGPROC_GPU)))); + +INSTANTIATE_TEST_CASE_P(BoxFilterTestGPU, BoxFilterTest, + Combine(Values(AbsTolerance_Float_Int(1e-5, 1e-3).to_compare_f()), + Values(/*CV_8UC1,*/ CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), + Values(3,5), + Values(cv::Size(1280, 720), + cv::Size(640, 480)), + Values(cv::BORDER_DEFAULT), + Values(-1, CV_32F), +/*init output matrices or not*/ testing::Bool(), + Values(cv::compile_args(IMGPROC_GPU)))); //TODO: 8UC1 doesn't work + +INSTANTIATE_TEST_CASE_P(SepFilterTestGPU_8U, SepFilterTest, + Combine(Values(AbsToleranceSepFilter(1e-4f).to_compare_f()), + Values(CV_8UC1, CV_8UC3), + Values(3), + Values(cv::Size(1280, 720), + cv::Size(640, 480)), + Values(-1, CV_16S, CV_32F), +/*init output matrices or not*/ testing::Bool(), + Values(cv::compile_args(IMGPROC_GPU)))); + +INSTANTIATE_TEST_CASE_P(SepFilterTestGPU_other, SepFilterTest, + Combine(Values(AbsToleranceSepFilter(1e-4f).to_compare_f()), + Values(CV_16UC1, CV_16SC1, CV_32FC1), + Values(3), + Values(cv::Size(1280, 720), + cv::Size(640, 480)), + Values(-1, CV_32F), +/*init output matrices or not*/ testing::Bool(), + Values(cv::compile_args(IMGPROC_GPU)))); + +INSTANTIATE_TEST_CASE_P(BlurTestGPU, BlurTest, + Combine(Values(AbsTolerance_Float_Int(1e-4, 1e-2).to_compare_f()), + Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), + Values(3,5), + Values(cv::Size(1280, 720), + cv::Size(640, 480)), + Values(cv::BORDER_DEFAULT), +/*init output matrices or not*/ testing::Bool(), + Values(cv::compile_args(IMGPROC_GPU)))); + +INSTANTIATE_TEST_CASE_P(gaussBlurTestGPU, GaussianBlurTest, + Combine(Values(AbsToleranceGaussianBlur_Float_Int(1e-5, 0.05).to_compare_f()), //TODO: too relaxed? + Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), + Values(3, 5), + Values(cv::Size(1280, 720), + cv::Size(640, 480)), +/*init output matrices or not*/ testing::Bool(), + Values(cv::compile_args(IMGPROC_GPU)))); + +INSTANTIATE_TEST_CASE_P(MedianBlurTestGPU, MedianBlurTest, + Combine(Values(AbsExact().to_compare_f()), + Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), + Values(3, 5), + Values(cv::Size(1280, 720), + cv::Size(640, 480)), +/*init output matrices or not*/ testing::Bool(), + Values(cv::compile_args(IMGPROC_GPU)))); + +INSTANTIATE_TEST_CASE_P(ErodeTestGPU, ErodeTest, + Combine(Values(AbsExact().to_compare_f()), + Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), + Values(3, 5), + Values(cv::Size(1280, 720), + cv::Size(640, 480)), + Values(cv::MorphShapes::MORPH_RECT, + cv::MorphShapes::MORPH_CROSS, + cv::MorphShapes::MORPH_ELLIPSE), +/*init output matrices or not*/ testing::Bool(), + Values(cv::compile_args(IMGPROC_GPU)))); + +INSTANTIATE_TEST_CASE_P(Erode3x3TestGPU, Erode3x3Test, + Combine(Values(AbsExact().to_compare_f()), + Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), + Values(cv::Size(1280, 720), + cv::Size(640, 480)), +/*init output matrices or not*/ testing::Bool(), + Values(1,2,4), + Values(cv::compile_args(IMGPROC_GPU)))); + +INSTANTIATE_TEST_CASE_P(DilateTestGPU, DilateTest, + Combine(Values(AbsExact().to_compare_f()), + Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), + Values(3, 5), + Values(cv::Size(1280, 720), + cv::Size(640, 480)), + Values(cv::MorphShapes::MORPH_RECT, + cv::MorphShapes::MORPH_CROSS, + cv::MorphShapes::MORPH_ELLIPSE), +/*init output matrices or not*/ testing::Bool(), + Values(cv::compile_args(IMGPROC_GPU)))); + +INSTANTIATE_TEST_CASE_P(Dilate3x3TestGPU, Dilate3x3Test, + Combine(Values(AbsExact().to_compare_f()), + Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), + Values(cv::Size(1280, 720), + cv::Size(640, 480)), +/*init output matrices or not*/ testing::Bool(), + Values(1,2,4), + Values(cv::compile_args(IMGPROC_GPU)))); + +INSTANTIATE_TEST_CASE_P(SobelTestGPU, SobelTest, + Combine(Values(AbsTolerance_Float_Int(1e-4, 1e-4).to_compare_f()), + Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1/*, CV_32FC1*/), //TODO: CV_32FC1 fails accuracy + Values(3, 5), + Values(cv::Size(1280, 720), + cv::Size(640, 480)), + Values(-1, CV_32F), + Values(0, 1), + Values(1, 2), +/*init output matrices or not*/ testing::Bool(), + Values(cv::compile_args(IMGPROC_GPU)))); + +INSTANTIATE_TEST_CASE_P(EqHistTestGPU, EqHistTest, + Combine(Values(AbsExact().to_compare_f()), + Values(cv::Size(1280, 720), + cv::Size(640, 480)), +/*init output matrices or not*/ testing::Bool(), + Values(cv::compile_args(IMGPROC_GPU)))); + +INSTANTIATE_TEST_CASE_P(CannyTestGPU, CannyTest, + Combine(Values(AbsTolerance_Float_Int(1e-4, 1e-2).to_compare_f()), + Values(CV_8UC1, CV_8UC3), + Values(cv::Size(1280, 720), + cv::Size(640, 480)), + Values(3.0, 120.0), + Values(125.0, 240.0), + Values(3, 5), + testing::Bool(), +/*init output matrices or not*/ testing::Bool(), + Values(cv::compile_args(IMGPROC_GPU)))); + +INSTANTIATE_TEST_CASE_P(RGB2GrayTestGPU, RGB2GrayTest, + Combine(Values(AbsExact().to_compare_f()), + Values(cv::Size(1280, 720), + cv::Size(640, 480)), +/*init output matrices or not*/ testing::Bool(), + Values(cv::compile_args(IMGPROC_GPU)))); + +INSTANTIATE_TEST_CASE_P(BGR2GrayTestGPU, BGR2GrayTest, + Combine(Values(AbsExact().to_compare_f()), + Values(cv::Size(1280, 720), + cv::Size(640, 480)), +/*init output matrices or not*/ testing::Bool(), + Values(cv::compile_args(IMGPROC_GPU)))); + +INSTANTIATE_TEST_CASE_P(RGB2YUVTestGPU, RGB2YUVTest, + Combine(Values(AbsExact().to_compare_f()), + Values(cv::Size(1280, 720), + cv::Size(640, 480)), +/*init output matrices or not*/ testing::Bool(), + Values(cv::compile_args(IMGPROC_GPU)))); + +INSTANTIATE_TEST_CASE_P(YUV2RGBTestGPU, YUV2RGBTest, + Combine(Values(AbsExact().to_compare_f()), + Values(cv::Size(1280, 720), + cv::Size(640, 480)), +/*init output matrices or not*/ testing::Bool(), + Values(cv::compile_args(IMGPROC_GPU)))); + +INSTANTIATE_TEST_CASE_P(RGB2LabTestGPU, RGB2LabTest, + Combine(Values(AbsExact().to_compare_f()), + Values(cv::Size(1280, 720), + cv::Size(640, 480)), +/*init output matrices or not*/ testing::Bool(), + Values(cv::compile_args(IMGPROC_GPU)))); + +INSTANTIATE_TEST_CASE_P(BGR2LUVTestGPU, BGR2LUVTest, + Combine(Values(ToleranceTriple(0.25 * 3, 0.01 * 3, 0.0001 * 3).to_compare_f()), + Values(cv::Size(1280, 720), + cv::Size(640, 480)), +/*init output matrices or not*/ testing::Bool(), + Values(cv::compile_args(IMGPROC_GPU)))); + +INSTANTIATE_TEST_CASE_P(LUV2BGRTestGPU, LUV2BGRTest, + Combine(Values(AbsExact().to_compare_f()), + Values(cv::Size(1280, 720), + cv::Size(640, 480)), +/*init output matrices or not*/ testing::Bool(), + Values(cv::compile_args(IMGPROC_GPU)))); + +INSTANTIATE_TEST_CASE_P(BGR2YUVTestGPU, BGR2YUVTest, + Combine(Values(AbsExact().to_compare_f()), + Values(cv::Size(1280, 720), + cv::Size(640, 480)), +/*init output matrices or not*/ testing::Bool(), + Values(cv::compile_args(IMGPROC_GPU)))); + +INSTANTIATE_TEST_CASE_P(YUV2BGRTestGPU, YUV2BGRTest, + Combine(Values(AbsExact().to_compare_f()), + Values(cv::Size(1280, 720), + cv::Size(640, 480)), +/*init output matrices or not*/ testing::Bool(), + Values(cv::compile_args(IMGPROC_GPU)))); + + +} // opencv_test diff --git a/modules/gapi/test/gpu/gapi_operators_tests_gpu.cpp b/modules/gapi/test/gpu/gapi_operators_tests_gpu.cpp new file mode 100644 index 0000000000..ff882dffba --- /dev/null +++ b/modules/gapi/test/gpu/gapi_operators_tests_gpu.cpp @@ -0,0 +1,72 @@ +// This file is part of OpenCV project. +// It is subject to the license terms in the LICENSE file found in the top-level directory +// of this distribution and at http://opencv.org/license.html. +// +// Copyright (C) 2018 Intel Corporation + + +#include "../test_precomp.hpp" +#include "../common/gapi_operators_tests.hpp" +#include "opencv2/gapi/gpu/core.hpp" + +#define CORE_GPU cv::gapi::core::gpu::kernels() + +namespace opencv_test +{ + + +INSTANTIATE_TEST_CASE_P(MathOperatorTestGPU, MathOperatorMatMatTest, + Combine(Values(AbsTolerance_Float_Int(1e-5, 1e-3).to_compare_f()), + Values( opPlusM, opMinusM, opDivM, + opGreater, opLess, opGreaterEq, opLessEq, opEq, opNotEq), + Values(CV_8UC1, CV_16SC1, CV_32FC1), + Values(cv::Size(1280, 720), + cv::Size(640, 480), + cv::Size(128, 128)), + Values(-1, CV_8U, CV_32F), +/*init output matrices or not*/ testing::Bool(), + Values(cv::compile_args(CORE_GPU)))); + +INSTANTIATE_TEST_CASE_P(MathOperatorTestGPU, MathOperatorMatScalarTest, + Combine(Values(AbsTolerance_Float_Int(1e-4, 1e-2).to_compare_f()), + Values( opPlus, opPlusR, opMinus, opMinusR, opMul, opMulR, opDiv, opDivR, + opGT, opLT, opGE, opLE, opEQ, opNE, + opGTR, opLTR, opGER, opLER, opEQR, opNER), + Values(CV_8UC1, CV_16SC1, CV_32FC1), + Values(cv::Size(1280, 720), + cv::Size(640, 480), + cv::Size(128, 128)), + Values(-1, CV_8U, CV_32F), +/*init output matrices or not*/ testing::Bool(), + Values(cv::compile_args(CORE_GPU)))); + +INSTANTIATE_TEST_CASE_P(BitwiseOperatorTestGPU, MathOperatorMatMatTest, + Combine(Values(AbsExact().to_compare_f()), + Values( opAnd, opOr, opXor ), + Values(CV_8UC1, CV_16UC1, CV_16SC1), + Values(cv::Size(1280, 720), + cv::Size(640, 480), + cv::Size(128, 128)), + Values(-1), +/*init output matrices or not*/ testing::Bool(), + Values(cv::compile_args(CORE_GPU)))); + +INSTANTIATE_TEST_CASE_P(BitwiseOperatorTestGPU, MathOperatorMatScalarTest, + Combine(Values(AbsExact().to_compare_f()), + Values( opAND, opOR, opXOR, opANDR, opORR, opXORR ), + Values(CV_8UC1, CV_16UC1, CV_16SC1), + Values(cv::Size(1280, 720), + cv::Size(640, 480), + cv::Size(128, 128)), + Values(-1), +/*init output matrices or not*/ testing::Bool(), + Values(cv::compile_args(CORE_GPU)))); + +INSTANTIATE_TEST_CASE_P(BitwiseNotOperatorTestGPU, NotOperatorTest, + Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1), + Values(cv::Size(1280, 720), + cv::Size(640, 480), + cv::Size(128, 128)), +/*init output matrices or not*/ testing::Bool(), + Values(cv::compile_args(CORE_GPU)))); +} diff --git a/modules/gapi/test/test_precomp.hpp b/modules/gapi/test/test_precomp.hpp index 899ebdd4b3..f56e291b65 100644 --- a/modules/gapi/test/test_precomp.hpp +++ b/modules/gapi/test/test_precomp.hpp @@ -18,6 +18,7 @@ #include "opencv2/gapi/imgproc.hpp" #include "opencv2/gapi/core.hpp" #include "opencv2/gapi/cpu/gcpukernel.hpp" +#include "opencv2/gapi/gpu/ggpukernel.hpp" #include "opencv2/gapi/gcompoundkernel.hpp" #include "opencv2/gapi/operators.hpp"