potok/opencv
1
0
Fork 0
mirror of https://github.com/opencv/opencv.git synced 2026-07-30 07:43:03 +04:00
Code Packages Releases Wiki Activity

Merge pull request #13851 from TolyaTalamanov:at/new-kernel-package-design

Browse Source 
G-API: Kernel package design (#13851)

* Remove cv::unite_policy from API

* Add check that all id in kernel package are unique

* Refactor checker id procedure

* Remove cv::gapi::GLookupOrder from API

* Implement cv::gapi::use_only

* Fix samples

* Fix docs

* Fix comments to review

* Remove unite_policy

* Fix GKernelPackage::backends()

* Fix comments to review

* Fix all_unique

* Fix comments to review

* Fix comments to review

* Remove out of date tests
This commit is contained in:
atalaman
2019-05-22 14:53:44 +03:00
committed by Alexander Alekhin
parent de977cc9c8
commit 935c02c0a3
15 changed files with 424 additions and 423 deletions
Download Patch File Download Diff File Expand all files Collapse all files
modules/gapi/test/common/gapi_compoundkernel_tests.cpp
+12 -12
View File
@@ -235,7 +235,7 @@ TEST(GCompoundKernel, ReplaceDefaultKernel)
cv::GMat in1, in2;
auto out = cv::gapi::add(in1, in2);
const auto custom_pkg = cv::gapi::kernels<GCompoundAddImpl>();
const auto full_pkg = cv::gapi::combine(cv::gapi::core::cpu::kernels(), custom_pkg, cv::unite_policy::REPLACE);
const auto full_pkg = cv::gapi::combine(cv::gapi::core::cpu::kernels(), custom_pkg);
cv::GComputation comp(cv::GIn(in1, in2), cv::GOut(out));
cv::Mat in_mat1 = cv::Mat::eye(3, 3, CV_8UC1),
in_mat2 = cv::Mat::eye(3, 3, CV_8UC1),
@@ -257,7 +257,7 @@ TEST(GCompoundKernel, DoubleAddC)
auto out = cv::gapi::addC(super, s);
const auto custom_pkg = cv::gapi::kernels<GCompoundDoubleAddCImpl>();
const auto full_pkg = cv::gapi::combine(custom_pkg, cv::gapi::core::cpu::kernels(), cv::unite_policy::KEEP);
const auto full_pkg = cv::gapi::combine(custom_pkg, cv::gapi::core::cpu::kernels());
cv::GComputation comp(cv::GIn(in1, in2, s), cv::GOut(out));
cv::Mat in_mat1 = cv::Mat::eye(3, 3, CV_8UC1),
@@ -282,7 +282,7 @@ TEST(GCompoundKernel, AddC)
auto out = cv::gapi::addC(super, s);
const auto custom_pkg = cv::gapi::kernels<GCompoundAddCImpl>();
const auto full_pkg = cv::gapi::combine(custom_pkg, cv::gapi::core::cpu::kernels(), cv::unite_policy::KEEP);
const auto full_pkg = cv::gapi::combine(custom_pkg, cv::gapi::core::cpu::kernels());
cv::GComputation comp(cv::GIn(in1, in2, s), cv::GOut(out));
cv::Mat in_mat1 = cv::Mat::eye(3, 3, CV_8UC1),
@@ -308,7 +308,7 @@ TEST(GCompoundKernel, MergeWithSplit)
auto out = cv::gapi::merge3(a2, b2, c2);
const auto custom_pkg = cv::gapi::kernels<GCompoundMergeWithSplitImpl>();
const auto full_pkg = cv::gapi::combine(custom_pkg, cv::gapi::core::cpu::kernels(), cv::unite_policy::KEEP);
const auto full_pkg = cv::gapi::combine(custom_pkg, cv::gapi::core::cpu::kernels());
cv::GComputation comp(cv::GIn(in), cv::GOut(out));
cv::Mat in_mat = cv::Mat::eye(3, 3, CV_8UC3), out_mat, ref_mat;
@@ -325,7 +325,7 @@ TEST(GCompoundKernel, AddWithAddC)
auto out = GCompoundAddWithAddC::on(in1, in2, s);
const auto custom_pkg = cv::gapi::kernels<GCompoundAddWithAddCImpl>();
const auto full_pkg = cv::gapi::combine(custom_pkg, cv::gapi::core::cpu::kernels(), cv::unite_policy::KEEP);
const auto full_pkg = cv::gapi::combine(custom_pkg, cv::gapi::core::cpu::kernels());
cv::GComputation comp(cv::GIn(in1, in2, s), cv::GOut(out));
cv::Mat in_mat1 = cv::Mat::eye(3, 3, CV_8UC1),
@@ -347,7 +347,7 @@ TEST(GCompoundKernel, SplitWithAdd)
std::tie(out1, out2) = GCompoundSplitWithAdd::on(in);
const auto custom_pkg = cv::gapi::kernels<GCompoundSplitWithAddImpl>();
const auto full_pkg = cv::gapi::combine(custom_pkg, cv::gapi::core::cpu::kernels(), cv::unite_policy::KEEP);
const auto full_pkg = cv::gapi::combine(custom_pkg, cv::gapi::core::cpu::kernels());
cv::GComputation comp(cv::GIn(in), cv::GOut(out1, out2));
cv::Mat in_mat = cv::Mat::eye(3, 3, CV_8UC3),
@@ -375,7 +375,7 @@ TEST(GCompoundKernel, ParallelAddC)
std::tie(out1, out2) = GCompoundParallelAddC::on(in1, in2);
const auto custom_pkg = cv::gapi::kernels<GCompoundParallelAddCImpl>();
const auto full_pkg = cv::gapi::combine(custom_pkg, cv::gapi::core::cpu::kernels(), cv::unite_policy::KEEP);
const auto full_pkg = cv::gapi::combine(custom_pkg, cv::gapi::core::cpu::kernels());
cv::GComputation comp(cv::GIn(in1, in2), cv::GOut(out1, out2));
cv::Mat in_mat = cv::Mat::eye(3, 3, CV_8UC1),
@@ -402,7 +402,7 @@ TEST(GCompoundKernel, GCompundKernelAndDefaultUseOneData)
auto out = cv::gapi::add(GCompoundAddWithAddC::on(in1, in2, s), cv::gapi::addC(in2, s));
const auto custom_pkg = cv::gapi::kernels<GCompoundAddWithAddCImpl>();
const auto full_pkg = cv::gapi::combine(custom_pkg, cv::gapi::core::cpu::kernels(), cv::unite_policy::KEEP);
const auto full_pkg = cv::gapi::combine(custom_pkg, cv::gapi::core::cpu::kernels());
cv::GComputation comp(cv::GIn(in1, in2, s), cv::GOut(out));
cv::Mat in_mat1 = cv::Mat::eye(3, 3, CV_8UC1),
@@ -428,7 +428,7 @@ TEST(GCompoundKernel, CompoundExpandedToCompound)
GCompoundAddWithAddCImpl,
GCompoundDoubleAddCImpl>();
const auto full_pkg = cv::gapi::combine(custom_pkg, cv::gapi::core::cpu::kernels(), cv::unite_policy::KEEP);
const auto full_pkg = cv::gapi::combine(custom_pkg, cv::gapi::core::cpu::kernels());
cv::GComputation comp(cv::GIn(in1, in2, s), cv::GOut(out));
cv::Mat in_mat1 = cv::Mat::eye(3, 3, CV_8UC1),
@@ -449,7 +449,7 @@ TEST(GCompoundKernel, MaxInArray)
GDoubleArray in;
auto out = GCompoundMaxInArray::on(in);
const auto custom_pkg = cv::gapi::kernels<GCompoundMaxInArrayImpl, GMaxInArrayImpl>();
const auto full_pkg = cv::gapi::combine(custom_pkg, cv::gapi::core::cpu::kernels(), cv::unite_policy::KEEP);
const auto full_pkg = cv::gapi::combine(custom_pkg, cv::gapi::core::cpu::kernels());
cv::GComputation comp(cv::GIn(in), cv::GOut(out));
std::vector<double> v = { 1, 5, -2, 3, 10, 2};
cv::Scalar out_scl;
@@ -465,7 +465,7 @@ TEST(GCompoundKernel, NegateArray)
GDoubleArray in;
GDoubleArray out = GCompoundNegateArray::on(in);
const auto custom_pkg = cv::gapi::kernels<GCompoundNegateArrayImpl, GNegateArrayImpl>();
const auto full_pkg = cv::gapi::combine(custom_pkg, cv::gapi::core::cpu::kernels(), cv::unite_policy::KEEP);
const auto full_pkg = cv::gapi::combine(custom_pkg, cv::gapi::core::cpu::kernels());
cv::GComputation comp(cv::GIn(in), cv::GOut(out));
std::vector<double> in_v = {1, 5, -2, -10, 3};
std::vector<double> out_v;
@@ -483,7 +483,7 @@ TEST(GCompoundKernel, RightGArrayHandle)
GDoubleArray a;
cv::GMat out = GCompoundGMatGArrayGMat::on(in[0], a, in[1]);
const auto custom_pkg = cv::gapi::kernels<GCompoundGMatGArrayGMatImpl, SetDiagKernelImpl>();
const auto full_pkg = cv::gapi::combine(custom_pkg, cv::gapi::core::cpu::kernels(), cv::unite_policy::KEEP);
const auto full_pkg = cv::gapi::combine(custom_pkg, cv::gapi::core::cpu::kernels());
cv::GComputation comp(cv::GIn(in[0], a, in[1]), cv::GOut(out));
std::vector<double> in_v(3, 1.0);
cv::Mat in_mat1 = cv::Mat::eye(cv::Size(3, 3), CV_8UC1),
modules/gapi/test/gapi_fluid_resize_test.cpp
+3 -4
View File
@@ -381,7 +381,7 @@ static auto fluidResizeTestPackage = [](int interpolation, cv::Size szIn, cv::Si
}break;
default: CV_Assert(false);
}
return combine(pkg, fluidTestPackage, unite_policy::KEEP);
return combine(pkg, fluidTestPackage);
#undef RESIZE_SWITCH
#undef RESIZE_CASE
@@ -743,7 +743,7 @@ TEST_P(NV12PlusResizeTest, Test)
auto out = cv::gapi::resize(rgb, out_sz, 0, 0, interp);
cv::GComputation c(cv::GIn(y, uv), cv::GOut(out));
auto pkg = cv::gapi::combine(fluidTestPackage, cv::gapi::core::fluid::kernels(), cv::unite_policy::KEEP);
auto pkg = cv::gapi::combine(fluidTestPackage, cv::gapi::core::fluid::kernels());
c.apply(cv::gin(y_mat, uv_mat), cv::gout(out_mat)
,cv::compile_args(pkg, cv::GFluidOutputRois{{to_own(roi)}}));
@@ -822,8 +822,7 @@ TEST_P(Preproc4lpiTest, Test)
cv::GComputation c(cv::GIn(y, uv), cv::GOut(out));
auto pkg = cv::gapi::combine(cv::gapi::core::fluid::kernels(),
fluidResizeTestPackage(interp, in_sz, out_sz, 4),
cv::unite_policy::REPLACE);
fluidResizeTestPackage(interp, in_sz, out_sz, 4));
c.apply(cv::gin(y_mat, uv_mat), cv::gout(out_mat)
,cv::compile_args(pkg, cv::GFluidOutputRois{{to_own(roi)}}));
modules/gapi/test/gapi_kernel_tests.cpp
+312 -85
View File
@@ -9,25 +9,126 @@
#include "opencv2/gapi/cpu/gcpukernel.hpp"
#include "gapi_mock_kernels.hpp"
#include "opencv2/gapi/cpu/gcpukernel.hpp" // cpu::backend
#include "opencv2/gapi/fluid/gfluidkernel.hpp" // fluid::backend
namespace opencv_test
{
namespace
{
G_TYPED_KERNEL(GClone, <GMat(GMat)>, "org.opencv.test.clone")
namespace I
{
static GMatDesc outMeta(GMatDesc in) { return in; }
};
GAPI_OCV_KERNEL(GCloneImpl, GClone)
{
static void run(const cv::Mat& in, cv::Mat &out)
G_TYPED_KERNEL(GClone, <GMat(GMat)>, "org.opencv.test.clone")
{
out = in.clone();
}
static GMatDesc outMeta(GMatDesc in) { return in; }
};
}
enum class KernelTags
{
CPU_CUSTOM_BGR2GRAY,
CPU_CUSTOM_CLONE,
CPU_CUSTOM_ADD,
FLUID_CUSTOM_BGR2GRAY,
FLUID_CUSTOM_CLONE,
FLUID_CUSTOM_ADD
};
}
class HeteroGraph: public ::testing::Test
{
public:
HeteroGraph()
{
auto tmp = I::GClone::on(cv::gapi::add(in[0], in[1]));
out = cv::gapi::imgproc::GBGR2Gray::on(tmp);
}
static void registerCallKernel(KernelTags kernel_tag) {
kernel_calls.insert(kernel_tag);
}
bool checkCallKernel(KernelTags kernel_tag) {
return ade::util::contains(kernel_calls, kernel_tag);
}
protected:
void SetUp() override
{
if (!kernel_calls.empty())
cv::util::throw_error(std::logic_error("Kernel call log has not been cleared!!!"));
}
void TearDown() override
{
kernel_calls.clear();
}
protected:
cv::GMat in[2], out;
static std::set<KernelTags> kernel_calls;
};
namespace cpu
{
GAPI_OCV_KERNEL(GClone, I::GClone)
{
static void run(const cv::Mat&, cv::Mat)
{
HeteroGraph::registerCallKernel(KernelTags::CPU_CUSTOM_CLONE);
}
};
GAPI_OCV_KERNEL(BGR2Gray, cv::gapi::imgproc::GBGR2Gray)
{
static void run(const cv::Mat&, cv::Mat&)
{
HeteroGraph::registerCallKernel(KernelTags::CPU_CUSTOM_BGR2GRAY);
}
};
GAPI_OCV_KERNEL(GAdd, cv::gapi::core::GAdd)
{
static void run(const cv::Mat&, const cv::Mat&, int, cv::Mat&)
{
HeteroGraph::registerCallKernel(KernelTags::CPU_CUSTOM_ADD);
}
};
}
namespace fluid
{
GAPI_FLUID_KERNEL(GClone, I::GClone, false)
{
static const int Window = 1;
static void run(const cv::gapi::fluid::View&, cv::gapi::fluid::Buffer)
{
HeteroGraph::registerCallKernel(KernelTags::FLUID_CUSTOM_CLONE);
}
};
GAPI_FLUID_KERNEL(BGR2Gray, cv::gapi::imgproc::GBGR2Gray, false)
{
static const int Window = 1;
static void run(const cv::gapi::fluid::View&, cv::gapi::fluid::Buffer&)
{
HeteroGraph::registerCallKernel(KernelTags::FLUID_CUSTOM_BGR2GRAY);
}
};
GAPI_FLUID_KERNEL(GAdd, cv::gapi::core::GAdd, false)
{
static const int Window = 1;
static void run(const cv::gapi::fluid::View&, const cv::gapi::fluid::View&,
int, cv::gapi::fluid::Buffer&)
{
HeteroGraph::registerCallKernel(KernelTags::FLUID_CUSTOM_ADD);
}
};
}
std::set<KernelTags> HeteroGraph::kernel_calls;
} // anonymous namespace
TEST(KernelPackage, Create)
{
@@ -57,17 +158,6 @@ TEST(KernelPackage, IncludesAPI)
EXPECT_FALSE(pkg.includesAPI<I::Qux>());
}
TEST(KernelPackage, IncludesAPI_Overlapping)
{
namespace J = Jupiter;
namespace S = Saturn;
auto pkg = cv::gapi::kernels<J::Foo, J::Bar, S::Foo, S::Bar>();
EXPECT_TRUE (pkg.includesAPI<I::Foo>());
EXPECT_TRUE (pkg.includesAPI<I::Bar>());
EXPECT_FALSE(pkg.includesAPI<I::Baz>());
EXPECT_FALSE(pkg.includesAPI<I::Qux>());
}
TEST(KernelPackage, Include_Add)
{
namespace J = Jupiter;
@@ -78,23 +168,6 @@ TEST(KernelPackage, Include_Add)
EXPECT_TRUE(pkg.includes<J::Qux>());
}
TEST(KernelPackage, Include_KEEP)
{
namespace J = Jupiter;
namespace S = Saturn;
auto pkg = cv::gapi::kernels<J::Foo, J::Bar>();
EXPECT_FALSE(pkg.includes<S::Foo>());
EXPECT_FALSE(pkg.includes<S::Bar>());
pkg.include<S::Bar>(); // default (KEEP)
EXPECT_TRUE(pkg.includes<J::Bar>());
EXPECT_TRUE(pkg.includes<S::Bar>());
pkg.include<S::Foo>(cv::unite_policy::KEEP); // explicit (KEEP)
EXPECT_TRUE(pkg.includes<J::Foo>());
EXPECT_TRUE(pkg.includes<S::Foo>());
}
TEST(KernelPackage, Include_REPLACE)
{
namespace J = Jupiter;
@@ -102,7 +175,7 @@ TEST(KernelPackage, Include_REPLACE)
auto pkg = cv::gapi::kernels<J::Foo, J::Bar>();
EXPECT_FALSE(pkg.includes<S::Bar>());
pkg.include<S::Bar>(cv::unite_policy::REPLACE);
pkg.include<S::Bar>();
EXPECT_FALSE(pkg.includes<J::Bar>());
EXPECT_TRUE(pkg.includes<S::Bar>());
}
@@ -111,31 +184,27 @@ TEST(KernelPackage, RemoveBackend)
{
namespace J = Jupiter;
namespace S = Saturn;
auto pkg = cv::gapi::kernels<J::Foo, J::Bar, S::Foo>();
auto pkg = cv::gapi::kernels<J::Foo, J::Bar, S::Baz>();
EXPECT_TRUE(pkg.includes<J::Foo>());
EXPECT_TRUE(pkg.includes<J::Bar>());
EXPECT_TRUE(pkg.includes<S::Foo>());
pkg.remove(J::backend());
EXPECT_FALSE(pkg.includes<J::Foo>());
EXPECT_FALSE(pkg.includes<J::Bar>());
EXPECT_TRUE(pkg.includes<S::Foo>());
EXPECT_TRUE(pkg.includes<S::Baz>());
};
TEST(KernelPackage, RemoveAPI)
{
namespace J = Jupiter;
namespace S = Saturn;
auto pkg = cv::gapi::kernels<J::Foo, J::Bar, S::Foo, S::Bar>();
auto pkg = cv::gapi::kernels<J::Foo, J::Bar>();
EXPECT_TRUE(pkg.includes<J::Foo>());
EXPECT_TRUE(pkg.includes<J::Bar>());
EXPECT_TRUE(pkg.includes<S::Foo>());
pkg.remove<I::Foo>();
EXPECT_TRUE(pkg.includes<J::Bar>());
EXPECT_TRUE(pkg.includes<S::Bar>());
EXPECT_FALSE(pkg.includes<J::Foo>());
EXPECT_FALSE(pkg.includes<S::Foo>());
};
TEST(KernelPackage, CreateHetero)
@@ -177,7 +246,7 @@ TEST(KernelPackage, Combine_REPLACE_Full)
namespace S = Saturn;
auto j_pkg = cv::gapi::kernels<J::Foo, J::Bar, J::Baz>();
auto s_pkg = cv::gapi::kernels<S::Foo, S::Bar, S::Baz>();
auto u_pkg = cv::gapi::combine(j_pkg, s_pkg, cv::unite_policy::REPLACE);
auto u_pkg = cv::gapi::combine(j_pkg, s_pkg);
EXPECT_EQ(3u, u_pkg.size());
EXPECT_FALSE(u_pkg.includes<J::Foo>());
@@ -194,7 +263,7 @@ TEST(KernelPackage, Combine_REPLACE_Partial)
namespace S = Saturn;
auto j_pkg = cv::gapi::kernels<J::Foo, J::Bar>();
auto s_pkg = cv::gapi::kernels<S::Bar>();
auto u_pkg = cv::gapi::combine(j_pkg, s_pkg, cv::unite_policy::REPLACE);
auto u_pkg = cv::gapi::combine(j_pkg, s_pkg);
EXPECT_EQ(2u, u_pkg.size());
EXPECT_TRUE (u_pkg.includes<J::Foo>());
@@ -208,38 +277,7 @@ TEST(KernelPackage, Combine_REPLACE_Append)
namespace S = Saturn;
auto j_pkg = cv::gapi::kernels<J::Foo, J::Bar>();
auto s_pkg = cv::gapi::kernels<S::Qux>();
auto u_pkg = cv::gapi::combine(j_pkg, s_pkg, cv::unite_policy::REPLACE);
EXPECT_EQ(3u, u_pkg.size());
EXPECT_TRUE(u_pkg.includes<J::Foo>());
EXPECT_TRUE(u_pkg.includes<J::Bar>());
EXPECT_TRUE(u_pkg.includes<S::Qux>());
}
TEST(KernelPackage, Combine_KEEP_AllDups)
{
namespace J = Jupiter;
namespace S = Saturn;
auto j_pkg = cv::gapi::kernels<J::Foo, J::Bar, J::Baz>();
auto s_pkg = cv::gapi::kernels<S::Foo, S::Bar, S::Baz>();
auto u_pkg = cv::gapi::combine(j_pkg ,s_pkg, cv::unite_policy::KEEP);
EXPECT_EQ(6u, u_pkg.size());
EXPECT_TRUE(u_pkg.includes<J::Foo>());
EXPECT_TRUE(u_pkg.includes<J::Bar>());
EXPECT_TRUE(u_pkg.includes<J::Baz>());
EXPECT_TRUE(u_pkg.includes<S::Foo>());
EXPECT_TRUE(u_pkg.includes<S::Bar>());
EXPECT_TRUE(u_pkg.includes<S::Baz>());
}
TEST(KernelPackage, Combine_KEEP_Append_NoDups)
{
namespace J = Jupiter;
namespace S = Saturn;
auto j_pkg = cv::gapi::kernels<J::Foo, J::Bar>();
auto s_pkg = cv::gapi::kernels<S::Qux>();
auto u_pkg = cv::gapi::combine(j_pkg, s_pkg, cv::unite_policy::KEEP);
auto u_pkg = cv::gapi::combine(j_pkg, s_pkg);
EXPECT_EQ(3u, u_pkg.size());
EXPECT_TRUE(u_pkg.includes<J::Foo>());
@@ -252,7 +290,7 @@ TEST(KernelPackage, TestWithEmptyLHS)
namespace J = Jupiter;
auto lhs = cv::gapi::kernels<>();
auto rhs = cv::gapi::kernels<J::Foo>();
auto pkg = cv::gapi::combine(lhs, rhs, cv::unite_policy::KEEP);
auto pkg = cv::gapi::combine(lhs, rhs);
EXPECT_EQ(1u, pkg.size());
EXPECT_TRUE(pkg.includes<J::Foo>());
@@ -263,22 +301,211 @@ TEST(KernelPackage, TestWithEmptyRHS)
namespace J = Jupiter;
auto lhs = cv::gapi::kernels<J::Foo>();
auto rhs = cv::gapi::kernels<>();
auto pkg = cv::gapi::combine(lhs, rhs, cv::unite_policy::KEEP);
auto pkg = cv::gapi::combine(lhs, rhs);
EXPECT_EQ(1u, pkg.size());
EXPECT_TRUE(pkg.includes<J::Foo>());
}
TEST(KernelPackage, Return_Unique_Backends)
{
auto pkg = cv::gapi::kernels<cpu::GClone, fluid::BGR2Gray, fluid::GAdd>();
EXPECT_EQ(2u, pkg.backends().size());
}
TEST(KernelPackage, Can_Use_Custom_Kernel)
{
cv::GMat in[2];
auto out = GClone::on(cv::gapi::add(in[0], in[1]));
auto out = I::GClone::on(cv::gapi::add(in[0], in[1]));
const auto in_meta = cv::GMetaArg(cv::GMatDesc{CV_8U,1,cv::Size(32,32)});
auto pkg = cv::gapi::kernels<GCloneImpl>();
auto pkg = cv::gapi::kernels<cpu::GClone>();
EXPECT_NO_THROW(cv::GComputation(cv::GIn(in[0], in[1]), cv::GOut(out)).
compile({in_meta, in_meta}, cv::compile_args(pkg)));
}
TEST_F(HeteroGraph, Call_Custom_Kernel_Default_Backend)
{
// in0 -> GCPUAdd -> tmp -> cpu::GClone -> GCPUBGR2Gray -> out
// ^
// |
// in1 -------`
cv::Mat in_mat1 = cv::Mat::eye(3, 3, CV_8UC3),
in_mat2 = cv::Mat::eye(3, 3, CV_8UC3),
out_mat;
auto pkg = cv::gapi::kernels<cpu::GClone>();
cv::GComputation(cv::GIn(in[0], in[1]), cv::GOut(out)).
apply(cv::gin(in_mat1, in_mat2), cv::gout(out_mat), cv::compile_args(pkg));
EXPECT_TRUE(checkCallKernel(KernelTags::CPU_CUSTOM_CLONE));
}
TEST_F(HeteroGraph, Call_Custom_Kernel_Not_Default_Backend)
{
// in0 -> GCPUAdd -> tmp -> fluid::GClone -> GCPUBGR2Gray -> out
// ^
// |
// in1 -------`
cv::Mat in_mat1 = cv::Mat::eye(3, 3, CV_8UC3),
in_mat2 = cv::Mat::eye(3, 3, CV_8UC3),
out_mat;
auto pkg = cv::gapi::kernels<fluid::GClone>();
cv::GComputation(cv::GIn(in[0], in[1]), cv::GOut(out)).
apply(cv::gin(in_mat1, in_mat2), cv::gout(out_mat), cv::compile_args(pkg));
EXPECT_TRUE(checkCallKernel(KernelTags::FLUID_CUSTOM_CLONE));
}
TEST_F(HeteroGraph, Replace_Default_To_Same_Backend)
{
// in0 -> GCPUAdd -> tmp -> cpu::GClone -> cpu::BGR2Gray -> out
// ^
// |
// in1 -------`
cv::Mat in_mat1 = cv::Mat::eye(3, 3, CV_8UC3),
in_mat2 = cv::Mat::eye(3, 3, CV_8UC3),
out_mat;
auto pkg = cv::gapi::kernels<cpu::GClone, cpu::BGR2Gray>();
cv::GComputation(cv::GIn(in[0], in[1]), cv::GOut(out)).
apply(cv::gin(in_mat1, in_mat2), cv::gout(out_mat), cv::compile_args(pkg));
EXPECT_TRUE(checkCallKernel(KernelTags::CPU_CUSTOM_BGR2GRAY));
}
TEST_F(HeteroGraph, Replace_Default_To_Another_Backend)
{
//in0 -> GCPUAdd -> tmp -> cpu::GClone -> fluid::BGR2Gray -> out
// ^
// |
//in1 --------`
cv::Mat in_mat1(300, 300, CV_8UC3),
in_mat2(300, 300, CV_8UC3),
out_mat;
auto pkg = cv::gapi::kernels<cpu::GClone, fluid::BGR2Gray>();
cv::GComputation(cv::GIn(in[0], in[1]), cv::GOut(out)).
apply(cv::gin(in_mat1, in_mat2), cv::gout(out_mat), cv::compile_args(pkg));
EXPECT_TRUE(checkCallKernel(KernelTags::FLUID_CUSTOM_BGR2GRAY));
}
TEST_F(HeteroGraph, Use_Only_Same_Backend)
{
//in0 -> cpu::GAdd -> tmp -> cpu::GClone -> cpu::BGR2Gray -> out
// ^
// |
//in1 --------`
cv::Mat in_mat1(300, 300, CV_8UC3),
in_mat2(300, 300, CV_8UC3),
out_mat;
auto pkg = cv::gapi::kernels<cpu::GAdd, cpu::GClone, cpu::BGR2Gray>();
cv::GComputation(cv::GIn(in[0], in[1]), cv::GOut(out)).
apply(cv::gin(in_mat1, in_mat2), cv::gout(out_mat), cv::compile_args(cv::gapi::use_only{pkg}));
EXPECT_TRUE(checkCallKernel(KernelTags::CPU_CUSTOM_ADD));
EXPECT_TRUE(checkCallKernel(KernelTags::CPU_CUSTOM_CLONE));
EXPECT_TRUE(checkCallKernel(KernelTags::CPU_CUSTOM_BGR2GRAY));
}
TEST_F(HeteroGraph, Use_Only_Another_Backend)
{
//in0 -> fluid::GAdd -> tmp -> fluid::GClone -> fluid::BGR2Gray -> out
// ^
// |
//in1 --------`
cv::Mat in_mat1(300, 300, CV_8UC3),
in_mat2(300, 300, CV_8UC3),
out_mat;
auto pkg = cv::gapi::kernels<fluid::GAdd, fluid::GClone, fluid::BGR2Gray>();
cv::GComputation(cv::GIn(in[0], in[1]), cv::GOut(out)).
apply(cv::gin(in_mat1, in_mat2), cv::gout(out_mat), cv::compile_args(cv::gapi::use_only{pkg}));
EXPECT_TRUE(checkCallKernel(KernelTags::FLUID_CUSTOM_ADD));
EXPECT_TRUE(checkCallKernel(KernelTags::FLUID_CUSTOM_CLONE));
EXPECT_TRUE(checkCallKernel(KernelTags::FLUID_CUSTOM_BGR2GRAY));
}
TEST_F(HeteroGraph, Use_Only_Hetero_Backend)
{
//in0 -> cpu::GAdd -> tmp -> fluid::GClone -> fluid::BGR2Gray -> out
// ^
// |
//in1 --------`
cv::Mat in_mat1(300, 300, CV_8UC3),
in_mat2(300, 300, CV_8UC3),
out_mat;
auto pkg = cv::gapi::kernels<cpu::GAdd, fluid::GClone, fluid::BGR2Gray>();
cv::GComputation(cv::GIn(in[0], in[1]), cv::GOut(out)).
apply(cv::gin(in_mat1, in_mat2), cv::gout(out_mat), cv::compile_args(cv::gapi::use_only{pkg}));
EXPECT_TRUE(checkCallKernel(KernelTags::CPU_CUSTOM_ADD));
EXPECT_TRUE(checkCallKernel(KernelTags::FLUID_CUSTOM_CLONE));
EXPECT_TRUE(checkCallKernel(KernelTags::FLUID_CUSTOM_BGR2GRAY));
}
TEST_F(HeteroGraph, Use_Only_Not_Found_Default)
{
//in0 -> GCPUAdd -> tmp -> fluid::GClone -> fluid::BGR2Gray -> out
// ^
// |
//in1 --------`
cv::Mat in_mat1(300, 300, CV_8UC3),
in_mat2(300, 300, CV_8UC3),
out_mat;
auto pkg = cv::gapi::kernels<fluid::GClone, fluid::BGR2Gray>();
EXPECT_ANY_THROW(cv::GComputation(cv::GIn(in[0], in[1]), cv::GOut(out)).
apply(cv::gin(in_mat1, in_mat2), cv::gout(out_mat), cv::compile_args(cv::gapi::use_only{pkg})));
}
TEST_F(HeteroGraph, Use_Only_Not_Found_Custom)
{
//in0 -> cpu::GAdd -> tmp -> fluid::GClone -> fluid::BGR2Gray -> out
// ^
// |
//in1 --------`
cv::Mat in_mat1(300, 300, CV_8UC3),
in_mat2(300, 300, CV_8UC3),
out_mat;
auto pkg = cv::gapi::kernels<cpu::GAdd, fluid::BGR2Gray>();
EXPECT_ANY_THROW(cv::GComputation(cv::GIn(in[0], in[1]), cv::GOut(out)).
apply(cv::gin(in_mat1, in_mat2), cv::gout(out_mat), cv::compile_args(cv::gapi::use_only{pkg})));
}
TEST_F(HeteroGraph, Use_Only_Other_Package_Ignored)
{
//in0 -> cpu::GAdd -> tmp -> fluid::GClone -> fluid::BGR2Gray -> out
// ^
// |
//in1 --------`
cv::Mat in_mat1(300, 300, CV_8UC3),
in_mat2(300, 300, CV_8UC3),
out_mat;
auto pkg = cv::gapi::kernels<cpu::GAdd, fluid::BGR2Gray>();
auto clone_pkg = cv::gapi::kernels<cpu::GClone>();
EXPECT_ANY_THROW(cv::GComputation(cv::GIn(in[0], in[1]), cv::GOut(out)).
apply(cv::gin(in_mat1, in_mat2), cv::gout(out_mat),
cv::compile_args(clone_pkg, cv::gapi::use_only{pkg})));
}
} // namespace opencv_test
modules/gapi/test/internal/gapi_int_recompilation_test.cpp
+1 -2
View File
@@ -197,8 +197,7 @@ TEST(GComputationCompile, ReshapeRois)
cv::randn(first_in_mat, cv::Scalar::all(127), cv::Scalar::all(40.f));
cv::Mat first_out_mat;
auto fluidKernels = cv::gapi::combine(gapi::imgproc::fluid::kernels(),
gapi::core::fluid::kernels(),
cv::unite_policy::REPLACE);
gapi::core::fluid::kernels());
cc.apply(first_in_mat, first_out_mat, cv::compile_args(fluidKernels));
auto first_comp = cc.priv().m_lastCompiled;
modules/gapi/test/internal/gapi_int_resolve_kernel_test.cpp
-119
View File
@@ -1,119 +0,0 @@
// 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 "../gapi_mock_kernels.hpp"
namespace opencv_test
{
TEST(Lookup, CreateOrder)
{
const auto order = cv::gapi::lookup_order({Jupiter::backend(),
Saturn::backend()});
EXPECT_EQ(2u, order.size());
EXPECT_EQ(Jupiter::backend(), order[0]);
EXPECT_EQ(Saturn ::backend(), order[1]);
}
TEST(Lookup, NoOrder)
{
namespace J = Jupiter;
namespace S = Saturn;
const auto pkg = cv::gapi::kernels<J::Foo, J::Bar, J::Baz,
S::Foo, S::Bar, S::Baz>();
EXPECT_NO_THROW (pkg.lookup<I::Foo>());
EXPECT_NO_THROW (pkg.lookup<I::Bar>());
EXPECT_NO_THROW (pkg.lookup<I::Baz>());
EXPECT_ANY_THROW(pkg.lookup<I::Qux>());
}
TEST(Lookup, Only_Jupiter)
{
namespace J = Jupiter;
namespace S = Saturn;
const auto pkg = cv::gapi::kernels<J::Foo, J::Bar, J::Baz,
S::Foo, S::Bar, S::Baz>();
auto order = cv::gapi::lookup_order({J::backend()});
EXPECT_EQ(J::backend(), pkg.lookup<I::Foo>(order));
EXPECT_EQ(J::backend(), pkg.lookup<I::Bar>(order));
EXPECT_EQ(J::backend(), pkg.lookup<I::Baz>(order));
EXPECT_ANY_THROW(pkg.lookup<I::Qux>(order));
}
TEST(Lookup, Only_Saturn)
{
namespace J = Jupiter;
namespace S = Saturn;
const auto pkg = cv::gapi::kernels<J::Foo, J::Bar, J::Baz,
S::Foo, S::Bar, S::Baz>();
auto order = cv::gapi::lookup_order({S::backend()});
EXPECT_EQ(S::backend(), pkg.lookup<I::Foo>(order));
EXPECT_EQ(S::backend(), pkg.lookup<I::Bar>(order));
EXPECT_EQ(S::backend(), pkg.lookup<I::Baz>(order));
EXPECT_ANY_THROW(pkg.lookup<I::Qux>(order));
}
TEST(Lookup, With_Order)
{
namespace J = Jupiter;
namespace S = Saturn;
const auto pkg = cv::gapi::kernels<J::Foo, J::Bar, J::Baz,
S::Foo, S::Bar, S::Baz>();
auto prefer_j = cv::gapi::lookup_order({J::backend(), S::backend()});
EXPECT_EQ(J::backend(), pkg.lookup<I::Foo>(prefer_j));
EXPECT_EQ(J::backend(), pkg.lookup<I::Bar>(prefer_j));
EXPECT_EQ(J::backend(), pkg.lookup<I::Baz>(prefer_j));
EXPECT_ANY_THROW(pkg.lookup<I::Qux>(prefer_j));
auto prefer_s = cv::gapi::lookup_order({S::backend(), J::backend()});
EXPECT_EQ(S::backend(), pkg.lookup<I::Foo>(prefer_s));
EXPECT_EQ(S::backend(), pkg.lookup<I::Bar>(prefer_s));
EXPECT_EQ(S::backend(), pkg.lookup<I::Baz>(prefer_s));
EXPECT_ANY_THROW(pkg.lookup<I::Qux>(prefer_s));
}
TEST(Lookup, NoOverlap)
{
namespace J = Jupiter;
namespace S = Saturn;
const auto pkg = cv::gapi::kernels<J::Foo, J::Bar, S::Baz, S::Qux>();
EXPECT_EQ(J::backend(), pkg.lookup<I::Foo>());
EXPECT_EQ(J::backend(), pkg.lookup<I::Bar>());
EXPECT_EQ(S::backend(), pkg.lookup<I::Baz>());
EXPECT_EQ(S::backend(), pkg.lookup<I::Qux>());
}
TEST(Lookup, ExtraBackend)
{
namespace J = Jupiter;
namespace S = Saturn;
const auto pkg = cv::gapi::kernels<J::Foo, J::Bar, J::Baz>();
// Even if pkg doesn't contain S kernels while S is preferable,
// it should work.
const auto prefer_sj = cv::gapi::lookup_order({S::backend(), J::backend()});
EXPECT_EQ(J::backend(), pkg.lookup<I::Foo>(prefer_sj));
EXPECT_EQ(J::backend(), pkg.lookup<I::Bar>(prefer_sj));
EXPECT_EQ(J::backend(), pkg.lookup<I::Baz>(prefer_sj));
// If search scope is limited to S only, neither J nor S kernels
// shouldn't be found
const auto only_s = cv::gapi::lookup_order({S::backend()});
EXPECT_ANY_THROW(pkg.lookup<I::Foo>(only_s));
EXPECT_ANY_THROW(pkg.lookup<I::Bar>(only_s));
EXPECT_ANY_THROW(pkg.lookup<I::Baz>(only_s));
}
} // namespace opencv_test