"${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"
)
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
#if !defined(GAPI_STANDALONE)
cv::Mat,
cv::Scalar,
+ cv::UMat,
#endif // !defined(GAPI_STANDALONE)
cv::gapi::own::Mat,
cv::gapi::own::Scalar,
#if !defined(GAPI_STANDALONE)
cv::Mat*,
cv::Scalar*,
+ cv::UMat*,
#endif // !defined(GAPI_STANDALONE)
cv::gapi::own::Mat*,
cv::gapi::own::Scalar*,
#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 {
--- /dev/null
+// 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 <opencv2/core/cvdef.h> // GAPI_EXPORTS
+#include <opencv2/gapi/gkernel.hpp> // 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
--- /dev/null
+// 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 <vector>
+#include <functional>
+#include <map>
+#include <unordered_map>
+
+#include <opencv2/core/mat.hpp>
+#include <opencv2/gapi/gcommon.hpp>
+#include <opencv2/gapi/gkernel.hpp>
+#include <opencv2/gapi/garg.hpp>
+
+// 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<typename T>
+ const T& inArg(int input) { return m_args.at(input).get<T>(); }
+
+ // 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<typename T> std::vector<T>& outVecR(int output) // FIXME: the same issue
+ {
+ return outVecRef(output).wref<T>();
+ }
+
+protected:
+ detail::VectorRef& outVecRef(int output);
+
+ std::vector<GArg> m_args;
+ std::unordered_map<std::size_t, GRunArgP> 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<void(GGPUContext &)>;
+
+ 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<class T> struct gpu_get_in;
+template<> struct gpu_get_in<cv::GMat>
+{
+ static cv::UMat get(GGPUContext &ctx, int idx) { return ctx.inMat(idx); }
+};
+template<> struct gpu_get_in<cv::GScalar>
+{
+ static cv::Scalar get(GGPUContext &ctx, int idx) { return to_ocv(ctx.inVal(idx)); }
+};
+template<typename U> struct gpu_get_in<cv::GArray<U> >
+{
+ static const std::vector<U>& get(GGPUContext &ctx, int idx) { return ctx.inArg<VectorRef>(idx).rref<U>(); }
+};
+template<class T> struct gpu_get_in
+{
+ static T get(GGPUContext &ctx, int idx) { return ctx.inArg<T>(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<typename... Outputs>
+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<class T> struct gpu_get_out;
+template<> struct gpu_get_out<cv::GMat>
+{
+ static tracked_cv_umat get(GGPUContext &ctx, int idx)
+ {
+ auto& r = ctx.outMatR(idx);
+ return{ r };
+ }
+};
+template<> struct gpu_get_out<cv::GScalar>
+{
+ static scalar_wrapper_gpu get(GGPUContext &ctx, int idx)
+ {
+ auto& s = ctx.outValR(idx);
+ return{ s };
+ }
+};
+template<typename U> struct gpu_get_out<cv::GArray<U> >
+{
+ static std::vector<U>& get(GGPUContext &ctx, int idx) { return ctx.outVecR<U>(idx); }
+};
+
+template<typename, typename, typename>
+struct GPUCallHelper;
+
+// FIXME: probably can be simplified with std::apply or analogue.
+template<typename Impl, typename... Ins, typename... Outs>
+struct GPUCallHelper<Impl, std::tuple<Ins...>, std::tuple<Outs...> >
+{
+ template<typename... Inputs>
+ struct call_and_postprocess
+ {
+ template<typename... Outputs>
+ 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<Inputs>(ins)..., outs...);
+
+ postprocess_gpu(outs...);
+ }
+ };
+
+ template<int... IIs, int... OIs>
+ static void call_impl(GGPUContext &ctx, detail::Seq<IIs...>, detail::Seq<OIs...>)
+ {
+ //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<decltype(gpu_get_in<Ins>::get(ctx, IIs))...>::call(gpu_get_in<Ins>::get(ctx, IIs)..., gpu_get_out<Outs>::get(ctx, OIs)...);
+ }
+
+ static void call(GGPUContext &ctx)
+ {
+ call_impl(ctx,
+ typename detail::MkSeq<sizeof...(Ins)>::type(),
+ typename detail::MkSeq<sizeof...(Outs)>::type());
+ }
+};
+
+} // namespace detail
+
+template<class Impl, class K>
+class GGPUKernelImpl: public detail::GPUCallHelper<Impl, typename K::InArgs, typename K::OutArgs>
+{
+ using P = detail::GPUCallHelper<Impl, typename K::InArgs, typename K::OutArgs>;
+
+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<Name, API>
+
+} // namespace cv
+
+#endif // OPENCV_GAPI_GGPUKERNEL_HPP
--- /dev/null
+// 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 <opencv2/core/cvdef.h> // GAPI_EXPORTS
+#include <opencv2/gapi/gkernel.hpp> // 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
class MulPerfTest : public TestPerfParams<tuple<cv::Size, MatType, int, cv::GCompileArgs>> {};
class MulDoublePerfTest : public TestPerfParams<tuple<cv::Size, MatType, int, cv::GCompileArgs>> {};
class MulCPerfTest : public TestPerfParams<tuple<cv::Size, MatType, int, cv::GCompileArgs>> {};
- class DivPerfTest : public TestPerfParams<tuple<cv::Size, MatType, int, cv::GCompileArgs>> {};
+ class DivPerfTest : public TestPerfParams<tuple<compare_f, cv::Size, MatType, int, cv::GCompileArgs>> {};
class DivCPerfTest : public TestPerfParams<tuple<cv::Size, MatType, int, cv::GCompileArgs>> {};
- class DivRCPerfTest : public TestPerfParams<tuple<cv::Size, MatType, int, cv::GCompileArgs>> {};
+ class DivRCPerfTest : public TestPerfParams<tuple<compare_f,cv::Size, MatType, int, cv::GCompileArgs>> {};
class MaskPerfTest : public TestPerfParams<tuple<cv::Size, MatType, cv::GCompileArgs>> {};
class MeanPerfTest : public TestPerfParams<tuple<cv::Size, MatType, cv::GCompileArgs>> {};
- class Polar2CartPerfTest : public TestPerfParams<tuple<cv::Size, cv::GCompileArgs>> {};
- class Cart2PolarPerfTest : public TestPerfParams<tuple<cv::Size, cv::GCompileArgs>> {};
+ class Polar2CartPerfTest : public TestPerfParams<tuple<compare_f, cv::Size, cv::GCompileArgs>> {};
+ class Cart2PolarPerfTest : public TestPerfParams<tuple<compare_f, cv::Size, cv::GCompileArgs>> {};
class CmpPerfTest : public TestPerfParams<tuple<CmpTypes, cv::Size, MatType, cv::GCompileArgs>> {};
class CmpWithScalarPerfTest : public TestPerfParams<tuple<CmpTypes, cv::Size, MatType, cv::GCompileArgs>> {};
class BitwisePerfTest : public TestPerfParams<tuple<bitwiseOp, cv::Size, MatType, cv::GCompileArgs>> {};
class MaxPerfTest : public TestPerfParams<tuple<cv::Size, MatType, cv::GCompileArgs>> {};
class AbsDiffPerfTest : public TestPerfParams<tuple<cv::Size, MatType, cv::GCompileArgs>> {};
class AbsDiffCPerfTest : public TestPerfParams<tuple<cv::Size, MatType, cv::GCompileArgs>> {};
- class SumPerfTest : public TestPerfParams<tuple<cv::Size, MatType, cv::GCompileArgs>> {};
- class AddWeightedPerfTest : public TestPerfParams<tuple<cv::Size, MatType, int, cv::GCompileArgs>> {};
- class NormPerfTest : public TestPerfParams<tuple<NormTypes, cv::Size, MatType, cv::GCompileArgs>> {};
+ class SumPerfTest : public TestPerfParams<tuple<cv::Size, MatType, double, cv::GCompileArgs>> {};
+ class AddWeightedPerfTest : public TestPerfParams<tuple<cv::Size, MatType, int, double, cv::GCompileArgs>> {};
+ class NormPerfTest : public TestPerfParams<tuple<NormTypes, cv::Size, MatType, double, cv::GCompileArgs>> {};
class IntegralPerfTest : public TestPerfParams<tuple<cv::Size, MatType, cv::GCompileArgs>> {};
class ThresholdPerfTest : public TestPerfParams<tuple<cv::Size, MatType, int, cv::GCompileArgs>> {};
class ThresholdOTPerfTest : public TestPerfParams<tuple<cv::Size, MatType, int, cv::GCompileArgs>> {};
class ConcatVertVecPerfTest : public TestPerfParams<tuple<cv::Size, MatType, cv::GCompileArgs>> {};
class LUTPerfTest : public TestPerfParams<tuple<MatType, MatType, cv::Size, cv::GCompileArgs>> {};
class ConvertToPerfTest : public TestPerfParams<tuple<MatType, int, cv::Size, cv::GCompileArgs>> {};
- class ResizePerfTest : public TestPerfParams<tuple<MatType, int, cv::Size, cv::Size, double, cv::GCompileArgs>> {};
- class ResizeFxFyPerfTest : public TestPerfParams<tuple<MatType, int, cv::Size, double, double, double, cv::GCompileArgs>> {};
+ class ResizePerfTest : public TestPerfParams<tuple<compare_f, MatType, int, cv::Size, cv::Size, cv::GCompileArgs>> {};
+ class ResizeFxFyPerfTest : public TestPerfParams<tuple<compare_f, MatType, int, cv::Size, double, double, cv::GCompileArgs>> {};
}
#endif // OPENCV_GAPI_CORE_PERF_TESTS_HPP
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);
}
// 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();
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);
}
// 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();
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;
{
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();
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);
}
// 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();
{
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);
}
// Comparison ////////////////////////////////////////////////////////////
- EXPECT_EQ(out_sum[0], out_sum_ocv[0]);
+ {
+ EXPECT_LE(abs(out_sum[0] - out_sum_ocv[0]), tolerance);
+ }
SANITY_CHECK_NOTHING();
}
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);
}
// 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<DST>( 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();
}
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);
}
// Comparison ////////////////////////////////////////////////////////////
- EXPECT_EQ(out_norm[0], out_norm_ocv[0]);
+ {
+ EXPECT_LE(abs(out_norm[0] - out_norm_ocv[0]), tolerance);
+ }
SANITY_CHECK_NOTHING();
}
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);
}
// 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();
}
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);
}
// 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();
}
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(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(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(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(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(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(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(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(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(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(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(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(Polar2CartPerfTestCPU, Polar2CartPerfTest,
- Combine(Values(szSmall128, szVGA, sz720p, sz1080p),
- 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(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(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(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(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(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(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(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(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(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(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(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(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))));
-
- 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, 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(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(InRangePerfTestCPU, InRangePerfTest,
- Combine(Values(szSmall128, szVGA, sz720p, sz1080p),
- Values(CV_8UC1),
- 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(Split4PerfTestCPU, Split4PerfTest,
- 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(Merge4PerfTestCPU, Merge4PerfTest,
- 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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(Polar2CartPerfTestCPU, Polar2CartPerfTest,
+ Combine(Values(AbsExact().to_compare_f()),
+ Values(szSmall128, szVGA, sz720p, sz1080p),
+ 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(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(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(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(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(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(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(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(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(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(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))));
+
+// 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(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(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, 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(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(InRangePerfTestCPU, InRangePerfTest,
+ Combine(Values(szSmall128, szVGA, sz720p, sz1080p),
+ Values(CV_8UC1),
+ 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(Split4PerfTestCPU, Split4PerfTest,
+ 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(Merge4PerfTestCPU, Merge4PerfTest,
+ 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(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(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(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(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(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(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(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(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(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))));
}
namespace opencv_test
{
- class AbsExact : public Wrappable<AbsExact>
- {
- public:
- AbsExact() {}
- bool operator() (const cv::Mat& in1, const cv::Mat& in2) const { return cv::countNonZero(in1 != in2) == 0; }
- private:
- };
-
- class AbsTolerance : public Wrappable<AbsTolerance>
- {
- 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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(YUV2BGRPerfTestCPU, YUV2BGRPerfTest,
+ Combine(Values(AbsExact().to_compare_f()),
+ Values(szVGA, sz720p, sz1080p),
+ Values(cv::compile_args(IMGPROC_CPU))));
}
--- /dev/null
+// 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))));
+}
--- /dev/null
+// 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))));
+
+}
#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
// 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<cv::gapi::own::Mat>()[rc.id];
switch (arg.index())
{
- case GRunArg::index_of<cv::gapi::own::Mat>() : mag_mat = util::get<cv::gapi::own::Mat>(arg); break;
+ case GRunArg::index_of<cv::gapi::own::Mat>() :
+ if (is_umat)
+ {
+ auto& mag_umat = mag.template slot<cv::UMat>()[rc.id];
+ mag_umat = to_ocv(util::get<cv::gapi::own::Mat>(arg)).getUMat(ACCESS_READ);
+ }
+ else
+ {
+ auto& mag_mat = mag.template slot<cv::gapi::own::Mat>()[rc.id];
+ mag_mat = util::get<cv::gapi::own::Mat>(arg);
+ }
+ break;
#if !defined(GAPI_STANDALONE)
- case GRunArg::index_of<cv::Mat>() : mag_mat = to_own(util::get<cv::Mat>(arg)); break;
+ case GRunArg::index_of<cv::Mat>() :
+ if (is_umat)
+ {
+ auto& mag_umat = mag.template slot<cv::UMat>()[rc.id];
+ mag_umat = (util::get<cv::UMat>(arg));
+ }
+ else
+ {
+ auto& mag_mat = mag.template slot<cv::gapi::own::Mat>()[rc.id];
+ mag_mat = to_own(util::get<cv::Mat>(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;
}
}
}
-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<cv::gapi::own::Mat>()[rc.id];
switch (arg.index())
{
- case GRunArgP::index_of<cv::gapi::own::Mat*>() : mag_mat = * util::get<cv::gapi::own::Mat*>(arg); break;
+ case GRunArgP::index_of<cv::gapi::own::Mat*>() :
+ if (is_umat)
+ {
+ auto& mag_umat = mag.template slot<cv::UMat>()[rc.id];
+ mag_umat = to_ocv(*(util::get<cv::gapi::own::Mat*>(arg))).getUMat(ACCESS_RW);
+ }
+ else
+ {
+ auto& mag_mat = mag.template slot<cv::gapi::own::Mat>()[rc.id];
+ mag_mat = *util::get<cv::gapi::own::Mat*>(arg);
+ }
+ break;
#if !defined(GAPI_STANDALONE)
- case GRunArgP::index_of<cv::Mat*>() : mag_mat = to_own(* util::get<cv::Mat*>(arg)); break;
+ case GRunArgP::index_of<cv::Mat*>() :
+ if (is_umat)
+ {
+ auto& mag_umat = mag.template slot<cv::UMat>()[rc.id];
+ mag_umat = (*util::get<cv::UMat*>(arg));
+ }
+ else
+ {
+ auto& mag_mat = mag.template slot<cv::gapi::own::Mat>()[rc.id];
+ mag_mat = to_own(*util::get<cv::Mat*>(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;
}
}
}
-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<cv::gapi::own::Mat>() [rc.id]);
+ case GShape::GMAT:
+ if (is_umat)
+ return GRunArgP(&mag.template slot<cv::UMat>()[rc.id]);
+ else
+ return GRunArgP(&mag.template slot<cv::gapi::own::Mat>()[rc.id]);
case GShape::GSCALAR: return GRunArgP(&mag.template slot<cv::gapi::own::Scalar>()[rc.id]);
// Note: .at() is intentional for GArray as object MUST be already there
// (and constructer by either bindIn/Out or resetInternal)
}
}
-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)
{
case GRunArgP::index_of<cv::gapi::own::Mat*>() : out_arg_data = util::get<cv::gapi::own::Mat*>(g_arg)->data; break;
#if !defined(GAPI_STANDALONE)
case GRunArgP::index_of<cv::Mat*>() : out_arg_data = util::get<cv::Mat*>(g_arg)->data; break;
+ case GRunArgP::index_of<cv::UMat*>() : out_arg_data = (util::get<cv::UMat*>(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<cv::gapi::own::Mat>().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<cv::UMat>().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<cv::gapi::own::Mat>().at(rc.id);
+ GAPI_Assert((out_arg_data == in_mag.data) && " data for output parameters was reallocated ?");
+ }
break;
}
{
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)
{
#if !defined(GAPI_STANDALONE)
case GRunArgP::index_of<cv::Mat*>(): return GMetaArg(descr_of(*util::get<cv::Mat*>(argp)));
+ case GRunArgP::index_of<cv::UMat*>(): return GMetaArg(descr_of(*util::get<cv::UMat*>(argp)));
case GRunArgP::index_of<cv::Scalar*>(): return GMetaArg(descr_of(*util::get<cv::Scalar*>(argp)));
#endif // !defined(GAPI_STANDALONE)
case GRunArgP::index_of<cv::gapi::own::Mat*>(): return GMetaArg(descr_of(*util::get<cv::gapi::own::Mat*>(argp)));
};
} // namespace magazine
-
+#if !defined(GAPI_STANDALONE)
+using Mag = magazine::Class<cv::gapi::own::Mat, cv::UMat, cv::gapi::own::Scalar, cv::detail::VectorRef>;
+#else
using Mag = magazine::Class<cv::gapi::own::Mat, cv::gapi::own::Scalar, cv::detail::VectorRef>;
+#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
--- /dev/null
+// 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 <functional>
+#include <unordered_set>
+
+#include <ade/util/algorithm.hpp>
+
+#include <ade/util/range.hpp>
+#include <ade/util/zip_range.hpp>
+#include <ade/util/chain_range.hpp>
+
+#include <ade/typed_graph.hpp>
+
+#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<cv::GGPUKernel>(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<ade::NodeHandle> &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<GGPUBackendImpl>());
+ return this_backend;
+}
+
+// GGPUExcecutable implementation //////////////////////////////////////////////
+cv::gimpl::GGPUExecutable::GGPUExecutable(const ade::Graph &g,
+ const std::vector<ade::NodeHandle> &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<NodeType>().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<Data>();
+ 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<ConstValue>().arg);
+ }
+ //preallocate internal Mats in advance
+ if (desc.storage == Data::Storage::INTERNAL && desc.shape == GShape::GMAT)
+ {
+ const auto mat_desc = util::get<cv::GMatDesc>(desc.meta);
+ const auto type = CV_MAKETYPE(mat_desc.depth, mat_desc.chan);
+ m_res.slot<cv::UMat>()[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<cv::gimpl::RcDesc>();
+ switch (ref.shape)
+ {
+ case GShape::GMAT: return GArg(m_res.slot<cv::UMat>()[ref.id]);
+ case GShape::GSCALAR: return GArg(m_res.slot<cv::gapi::own::Scalar>()[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<cv::detail::VectorRef>().at(ref.id));
+ default:
+ util::throw_error(std::logic_error("Unsupported GShape type"));
+ break;
+ }
+}
+
+void cv::gimpl::GGPUExecutable::run(std::vector<InObj> &&input_objs,
+ std::vector<OutObj> &&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<Data>();
+
+ if ( desc.storage == Data::Storage::INTERNAL
+ && !util::holds_alternative<util::monostate>(desc.ctor))
+ {
+ // FIXME: Note that compile-time constant data objects (like
+ // a value-initialized GArray<T>) 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<Op>();
+
+ // Obtain our real execution unit
+ // TODO: Should kernels be copyable?
+ GGPUKernel k = gcm.metadata(op_info.nh).get<Unit>().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);
+}
--- /dev/null
+// 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> // map
+#include <unordered_map> // unordered_map
+#include <tuple> // tuple
+#include <ade/util/algorithm.hpp> // 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<OperationInfo> m_script;
+ // List of all resources in graph (both internal and external)
+ std::vector<ade::NodeHandle> 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<ade::NodeHandle> &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<InObj> &&input_objs,
+ std::vector<OutObj> &&output_objs) override;
+};
+
+}}
+
+#endif // OPENCV_GAPI_GGPUBACKEND_HPP
--- /dev/null
+// 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<cv::UMat> 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<cv::UMat> 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<cv::UMat> 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<cv::UMat> 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;
+}
--- /dev/null
+// 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 <map>
+#include <string>
+
+#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<std::string, cv::GGPUKernel> &kmap);
+
+}
+}
+
+#endif // OPENCV_GAPI_GGPUCORE_HPP
--- /dev/null
+// 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;
+}
--- /dev/null
+// 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 <map>
+#include <string>
+
+#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<std::string, cv::GGPUKernel> &kmap);
+
+}}
+
+#endif // OPENCV_GAPI_GGPUIMGPROC_HPP
--- /dev/null
+// 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 <cassert>
+
+#include "opencv2/gapi/gpu/ggpukernel.hpp"
+
+const cv::UMat& cv::GGPUContext::inMat(int input)
+{
+ return (inArg<cv::UMat>(input));
+}
+
+cv::UMat& cv::GGPUContext::outMatR(int output)
+{
+ return (*(util::get<cv::UMat*>(m_results.at(output))));
+}
+
+const cv::gapi::own::Scalar& cv::GGPUContext::inVal(int input)
+{
+ return inArg<cv::gapi::own::Scalar>(input);
+}
+
+cv::gapi::own::Scalar& cv::GGPUContext::outValR(int output)
+{
+ return *util::get<cv::gapi::own::Scalar*>(m_results.at(output));
+}
+
+cv::detail::VectorRef& cv::GGPUContext::outVecRef(int output)
+{
+ return util::get<cv::detail::VectorRef>(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);
+}
struct MaxTest : public TestParams<std::tuple<int,cv::Size,bool, cv::GCompileArgs>>{};
struct AbsDiffTest : public TestParams<std::tuple<int,cv::Size,bool, cv::GCompileArgs>>{};
struct AbsDiffCTest : public TestParams<std::tuple<int,cv::Size,bool, cv::GCompileArgs>> {};
-struct SumTest : public TestParams<std::tuple<int, cv::Size,bool, cv::GCompileArgs>> {};
-struct AddWeightedTest : public TestParams<std::tuple<int,cv::Size,int,bool, cv::GCompileArgs>>{};
-struct NormTest : public TestParams<std::tuple<NormTypes,int,cv::Size, cv::GCompileArgs>>{};
+struct SumTest : public TestParams<std::tuple<int, cv::Size,bool,double,cv::GCompileArgs>> {};
+struct AddWeightedTest : public TestParams<std::tuple<int,cv::Size,int,bool,double,cv::GCompileArgs>>{};
+struct NormTest : public TestParams<std::tuple<NormTypes,int,cv::Size, double, cv::GCompileArgs>>{};
struct IntegralTest : public TestWithParam<std::tuple<int,cv::Size, cv::GCompileArgs>> {};
struct ThresholdTest : public TestParams<std::tuple<int,cv::Size,int,bool, cv::GCompileArgs>> {};
struct ThresholdOTTest : public TestParams<std::tuple<int,cv::Size,int,bool, cv::GCompileArgs>> {};
struct InRangeTest : public TestParams<std::tuple<int,cv::Size,bool, cv::GCompileArgs>> {};
struct Split3Test : public TestParams<std::tuple<cv::Size, cv::GCompileArgs>> {};
struct Split4Test : public TestParams<std::tuple<cv::Size, cv::GCompileArgs>> {};
-struct ResizeTest : public TestWithParam<std::tuple<int, int, cv::Size, cv::Size, double, cv::GCompileArgs>> {};
-struct ResizeTestFxFy : public TestWithParam<std::tuple<int, int, cv::Size, double, double, double, cv::GCompileArgs>> {};
+struct ResizeTest : public TestWithParam<std::tuple<compare_f, int, int, cv::Size, cv::Size, cv::GCompileArgs>> {};
+struct ResizeTestFxFy : public TestWithParam<std::tuple<compare_f, int, int, cv::Size, double, double, cv::GCompileArgs>> {};
struct Merge3Test : public TestParams<std::tuple<cv::Size, cv::GCompileArgs>> {};
struct Merge4Test : public TestParams<std::tuple<cv::Size, cv::GCompileArgs>> {};
struct RemapTest : public TestParams<std::tuple<int,cv::Size,bool, cv::GCompileArgs>> {};
{
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;
}
// Comparison //////////////////////////////////////////////////////////////
{
- EXPECT_EQ(out_sum[0], out_sum_ocv[0]);
+ EXPECT_LE(abs(out_sum[0] - out_sum_ocv[0]), tolerance);
}
}
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);
// 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;
}
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;
// Comparison //////////////////////////////////////////////////////////////
{
- EXPECT_EQ(out_norm[0], out_norm_ocv[0]);
+ EXPECT_LE(abs(out_norm[0] - out_norm_ocv[0]), tolerance);
}
}
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;
}
}
-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);
}
// 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)
[](const cv::Mat& in1, const cv::Mat& in2, cv::Mat& out){cv::bitwise_xor(in1, in2, out);}};
} // anonymous namespace
-struct MathOperatorMatScalarTest : public TestParams<std::tuple<g_api_ocv_pair_mat_scalar,int,cv::Size,int,bool,cv::GCompileArgs>>{};
-struct MathOperatorMatMatTest : public TestParams<std::tuple<g_api_ocv_pair_mat_mat,int,cv::Size,int,bool,cv::GCompileArgs>>{};
+struct MathOperatorMatScalarTest : public TestParams<std::tuple<compare_f, g_api_ocv_pair_mat_scalar,int,cv::Size,int,bool,cv::GCompileArgs>>{};
+struct MathOperatorMatMatTest : public TestParams<std::tuple<compare_f, g_api_ocv_pair_mat_mat,int,cv::Size,int,bool,cv::GCompileArgs>>{};
struct NotOperatorTest : public TestParams<std::tuple<int,cv::Size,bool,cv::GCompileArgs>> {};
} // 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;
// 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;
// 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);
}
}
}
};
+class AbsExact : public Wrappable<AbsExact>
+{
+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<AbsTolerance>
+{
+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<AbsTolerance_Float_Int>
+{
+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<AbsToleranceSepFilter>
+{
+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<AbsToleranceGaussianBlur_Float_Int>
+{
+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<ToleranceRGBBGR>
+{
+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<ToleranceTriple>
+{
+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<AbsToleranceSobel>
+{
+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;
+};
+
+
}
namespace opencv_test
{
+
// FIXME: Wut? See MulTestCPU/MathOpTest below (duplicate?)
INSTANTIATE_TEST_CASE_P(AddTestCPU, MathOpTest,
Combine(Values(ADD, MUL),
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,
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,
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());
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,
#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),
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,
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),
cv::Size(128, 128),
cv::Size(64, 64),
cv::Size(30, 30)),
- Values(0.0),
Values(cv::compile_args(CORE_FLUID))));
//----------------------------------------------------------------------
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),
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,
namespace opencv_test
{
-class AbsExact : public Wrappable<AbsExact>
-{
-public:
- AbsExact() {}
- bool operator() (const cv::Mat& in1, const cv::Mat& in2) const { return cv::countNonZero(in1 != in2)==0; }
-private:
-};
-
-class AbsTolerance : public Wrappable<AbsTolerance>
-{
-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()),
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),
namespace opencv_test
{
-class AbsExactFluid : public Wrappable<AbsExactFluid>
-{
-public:
- AbsExactFluid() {}
- bool operator() (const cv::Mat& in1, const cv::Mat& in2) const { return cv::countNonZero(in1 != in2) == 0; }
-private:
-};
-
-
-class AbsToleranceFluid : public Wrappable<AbsToleranceFluid>
-{
-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<AbsToleranceSobelFluid>
-{
-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<AbsTolerance32FFluid>
-{
-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<AbsToleranceSepFilterFluid>
-{
-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<AbsToleranceGaussianBlurFluid>
-{
-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<AbsToleranceRGBBGRFluid>
-{
-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<ToleranceTripleFluid>
-{
-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),
// 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),
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),
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),
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),
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),
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),
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),
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),
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),
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),
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)),
+ cv::Size(640, 480),
+ cv::Size(128, 128)),
Values(-1, CV_8U, CV_32F),
- /*init output matrices or not*/ testing::Bool(),
+/*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(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_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))));
-
- 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))));
+ 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))));
}
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),
+//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)),
- Values(-1),
- /*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))));
- //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(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))));
- 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_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)),
- /*init output matrices or not*/ testing::Bool(),
- Values(cv::compile_args(CORE_FLUID))));
+ 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))));
}
--- /dev/null
+// 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
+}
--- /dev/null
+// 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
--- /dev/null
+// 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))));
+}
#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"
projects / platform / upstream / opencv.git / commitdiff