mirror/opencv
1
0
Fork 0
mirror of https://github.com/opencv/opencv.git synced 2024-12-15 01:39:10 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity
e70ba29d95
opencv/modules/gapi/test/internal/gapi_int_island_tests.cpp
Ruslan Garnov 1f517b8a02 Merge pull request #13943 from rgarnov:export_headers_for_backend_development 
G-API external backend development (#13943)

* Moved HostCtor and ConstVal from gapi_priv.hpp to objref.hpp

* Added gmodel_priv.hpp, added export of symbols from gmodel.hpp

* Added export of binInArg and bindOutArg

* Renamed gapi_priv.*pp -> gorigin.*pp

* Added a fixme on collecting exports inside one class
2019-04-17 21:54:47 +03:00

655 lines
29 KiB
C++
Raw Blame History

// 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 "compiler/gmodel.hpp"
#include "compiler/gcompiled_priv.hpp"
#include "compiler/gmodel_priv.hpp"
namespace opencv_test
{
////////////////////////////////////////////////////////////////////////////////
// Tests on a plain graph
//
// (in) -> Blur1 -> (tmp0) -> Blur2 -> (tmp1) -> Blur3 -> (tmp2) -> Blur4 -> (out)
//
namespace
{
struct PlainIslandsFixture
{
cv::GMat in;
cv::GMat tmp[3];
cv::GMat out;
PlainIslandsFixture()
{
tmp[0] = cv::gapi::boxFilter(in, -1, cv::Size(3,3));
tmp[1] = cv::gapi::boxFilter(tmp[0], -1, cv::Size(3,3));
tmp[2] = cv::gapi::boxFilter(tmp[1], -1, cv::Size(3,3));
out = cv::gapi::boxFilter(tmp[2], -1, cv::Size(3,3));
}
};
struct Islands: public ::testing::Test, public PlainIslandsFixture {};
using GIntArray = GArray<int>;
G_TYPED_KERNEL(CreateMatWithDiag, <GMat(GIntArray)>, "test.array.create_mat_with_diag")
{
static GMatDesc outMeta(const GArrayDesc&) { return cv::GMatDesc{CV_32S, 1,{3, 3}}; }
};
GAPI_OCV_KERNEL(CreateMatWithDiagImpl, CreateMatWithDiag)
{
static void run(const std::vector<int> &in, cv::Mat& out)
{
auto size = static_cast<int>(in.size());
out = Mat::zeros(size, size, CV_32SC1);
for(int i = 0; i < out.rows; i++)
{
auto* row = out.ptr<int>(i);
row[i] = in[i];
}
}
};
G_TYPED_KERNEL(Mat2Array, <GIntArray(GMat)>, "test.array.mat2array")
{
static GArrayDesc outMeta(const GMatDesc&) { return empty_array_desc(); }
};
GAPI_OCV_KERNEL(Mat2ArrayImpl, Mat2Array)
{
static void run(const cv::Mat& in, std::vector<int> &out)
{
GAPI_Assert(in.depth() == CV_32S && in.isContinuous());
out.reserve(in.cols * in.rows);
out.assign((int*)in.datastart, (int*)in.dataend);
}
};
}
TEST_F(Islands, SmokeTest)
{
// (in) -> Blur1 -> (tmp0) -> Blur2 -> (tmp1) -> Blur3 -> (tmp2) -> Blur4 -> (out)
// : "test" :
// :<------------------------->:
cv::gapi::island("test", cv::GIn(tmp[0]), cv::GOut(tmp[2]));
auto cc = cv::GComputation(in, out).compile(cv::GMatDesc{CV_8U,1,{640,480}});
const auto &gm = cc.priv().model();
const auto tmp0_nh = cv::gimpl::GModel::dataNodeOf(gm, tmp[0]);
const auto tmp1_nh = cv::gimpl::GModel::dataNodeOf(gm, tmp[1]);
const auto tmp2_nh = cv::gimpl::GModel::dataNodeOf(gm, tmp[2]);
// tmp1 and tmp3 is not a part of any island
EXPECT_FALSE(gm.metadata(tmp0_nh).contains<cv::gimpl::Island>());
EXPECT_FALSE(gm.metadata(tmp2_nh).contains<cv::gimpl::Island>());
// tmp2 is part of "test" island
EXPECT_TRUE(gm.metadata(tmp1_nh).contains<cv::gimpl::Island>());
EXPECT_EQ("test", gm.metadata(tmp1_nh).get<cv::gimpl::Island>().island);
}
TEST_F(Islands, TwoIslands)
{
// (in) -> Blur1 -> (tmp0) -> Blur2 -> (tmp1) -> Blur3 -> (tmp2) -> Blur4 -> (out)
// : "test1" : : "test2" :
// :<---------------------------->: :<--------------------------------->
EXPECT_NO_THROW(cv::gapi::island("test1", cv::GIn(in), cv::GOut(tmp[1])));
EXPECT_NO_THROW(cv::gapi::island("test2", cv::GIn(tmp[1]), cv::GOut(out)));
auto cc = cv::GComputation(in, out).compile(cv::GMatDesc{CV_8U,1,{640,480}});
const auto &gm = cc.priv().model();
const auto in_nh = cv::gimpl::GModel::dataNodeOf(gm, in);
const auto tmp0_nh = cv::gimpl::GModel::dataNodeOf(gm, tmp[0]);
const auto tmp1_nh = cv::gimpl::GModel::dataNodeOf(gm, tmp[1]);
const auto tmp2_nh = cv::gimpl::GModel::dataNodeOf(gm, tmp[2]);
const auto out_nh = cv::gimpl::GModel::dataNodeOf(gm, out);
// Only tmp0 and tmp2 should be listed in islands.
EXPECT_TRUE (gm.metadata(tmp0_nh).contains<cv::gimpl::Island>());
EXPECT_TRUE (gm.metadata(tmp2_nh).contains<cv::gimpl::Island>());
EXPECT_FALSE(gm.metadata(in_nh) .contains<cv::gimpl::Island>());
EXPECT_FALSE(gm.metadata(tmp1_nh).contains<cv::gimpl::Island>());
EXPECT_FALSE(gm.metadata(out_nh) .contains<cv::gimpl::Island>());
EXPECT_EQ("test1", gm.metadata(tmp0_nh).get<cv::gimpl::Island>().island);
EXPECT_EQ("test2", gm.metadata(tmp2_nh).get<cv::gimpl::Island>().island);
}
// FIXME: Disabled since currently merge procedure merges two into one
// successfully
TEST_F(Islands, DISABLED_Two_Islands_With_Same_Name_Should_Fail)
{
// (in) -> Blur1 -> (tmp0) -> Blur2 -> (tmp1) -> Blur3 -> (tmp2) -> Blur4 -> (out)
// : "test1" : : "test1" :
// :<---------------------------->: :<--------------------------------->
EXPECT_NO_THROW(cv::gapi::island("test1", cv::GIn(in), cv::GOut(tmp[1])));
EXPECT_NO_THROW(cv::gapi::island("test1", cv::GIn(tmp[1]), cv::GOut(out)));
EXPECT_ANY_THROW(cv::GComputation(in, out).compile(cv::GMatDesc{CV_8U,1,{640,480}}));
}
// (in) -> Blur1 -> (tmp0) -> Blur2 -> (tmp1) -> Blur3 -> (tmp2) -> Blur4 -> (out)
// : "test1": : :
// :<----------------:----------->: :
// : :
// : "test2" :
// :<------------------------->:
TEST_F(Islands, OverlappingIslands1)
{
EXPECT_NO_THROW (cv::gapi::island("test1", cv::GIn(in), cv::GOut(tmp[1])));
EXPECT_ANY_THROW(cv::gapi::island("test2", cv::GIn(tmp[0]), cv::GOut(tmp[2])));
}
TEST_F(Islands, OverlappingIslands2)
{
EXPECT_NO_THROW (cv::gapi::island("test2", cv::GIn(tmp[0]), cv::GOut(tmp[2])));
EXPECT_ANY_THROW(cv::gapi::island("test1", cv::GIn(in), cv::GOut(tmp[1])));
}
////////////////////////////////////////////////////////////////////////////////
// Tests on a complex graph
//
// (in0) -> Not -> (tmp0) --> Add ---------> (tmp2) --> AddC -------> (out0)
// ^ ^
// (in1) -> Blur -> (tmp1) ----'--> Sum ----> (scl0) ----'
// :
// `------------> Median -> (tmp3) --> Blur -------> (out1)
//
namespace
{
struct ComplexIslandsFixture
{
cv::GMat in[2];
cv::GMat tmp[4];
cv::GScalar scl;
cv::GMat out[2];
ComplexIslandsFixture()
{
tmp[0] = cv::gapi::bitwise_not(in[0]);
tmp[1] = cv::gapi::boxFilter(in[1], -1, cv::Size(3,3));
tmp[2] = tmp[0] + tmp[1]; // FIXME: handle tmp[2] = tmp[0]+tmp[2] typo
scl = cv::gapi::sum(tmp[1]);
tmp[3] = cv::gapi::medianBlur(tmp[1], 3);
out[0] = tmp[2] + scl;
out[1] = cv::gapi::boxFilter(tmp[3], -1, cv::Size(3,3));
}
};
struct ComplexIslands: public ::testing::Test, public ComplexIslandsFixture {};
} // namespace
TEST_F(ComplexIslands, SmokeTest)
{
// isl0 #internal1
// ........................... ........
// (in0) -> Not -> (tmp0) --> Add ---------> (tmp2) --> AddC -------> (out0)
// :............ ........^...: :.^....:
// ... : :
// (in1) -> Blur -> (tmp1) ----'--> Sum ----> (scl0) ----'
// : isl1
// : ..............................
// `------------> Median -> (tmp3) --> Blur -------> (out1)
// :............................:
cv::gapi::island("isl0", cv::GIn(in[0], tmp[1]), cv::GOut(tmp[2]));
cv::gapi::island("isl1", cv::GIn(tmp[1]), cv::GOut(out[1]));
auto cc = cv::GComputation(cv::GIn(in[0], in[1]), cv::GOut(out[0], out[1]))
.compile(cv::GMatDesc{CV_8U,1,{640,480}},
cv::GMatDesc{CV_8U,1,{640,480}});
const auto &gm = cc.priv().model();
const auto in0_nh = cv::gimpl::GModel::dataNodeOf(gm, in[0]);
const auto in1_nh = cv::gimpl::GModel::dataNodeOf(gm, in[1]);
const auto tmp0_nh = cv::gimpl::GModel::dataNodeOf(gm, tmp[0]);
const auto tmp1_nh = cv::gimpl::GModel::dataNodeOf(gm, tmp[1]);
const auto tmp2_nh = cv::gimpl::GModel::dataNodeOf(gm, tmp[2]);
const auto tmp3_nh = cv::gimpl::GModel::dataNodeOf(gm, tmp[3]);
const auto scl_nh = cv::gimpl::GModel::dataNodeOf(gm, scl);
const auto out0_nh = cv::gimpl::GModel::dataNodeOf(gm, out[0]);
const auto out1_nh = cv::gimpl::GModel::dataNodeOf(gm, out[1]);
// tmp0, tmp3 are in islands, others are not
EXPECT_TRUE(gm.metadata(tmp0_nh) .contains<cv::gimpl::Island>()); // isl0
EXPECT_TRUE(gm.metadata(tmp3_nh) .contains<cv::gimpl::Island>()); // isl1
EXPECT_FALSE(gm.metadata(in0_nh) .contains<cv::gimpl::Island>()); // (input is never fused)
EXPECT_FALSE(gm.metadata(in1_nh) .contains<cv::gimpl::Island>()); // (input is never fused)
EXPECT_TRUE (gm.metadata(tmp1_nh).contains<cv::gimpl::Island>()); // <internal island>
EXPECT_FALSE(gm.metadata(tmp2_nh).contains<cv::gimpl::Island>()); // #not fused as cycle-causing#
EXPECT_FALSE(gm.metadata(scl_nh) .contains<cv::gimpl::Island>()); // #not fused as cycle-causing#
EXPECT_FALSE(gm.metadata(out0_nh).contains<cv::gimpl::Island>()); // (output is never fused)
EXPECT_FALSE(gm.metadata(out1_nh).contains<cv::gimpl::Island>()); // (output is never fused)
EXPECT_EQ("isl0", gm.metadata(tmp0_nh).get<cv::gimpl::Island>().island);
EXPECT_EQ("isl1", gm.metadata(tmp3_nh).get<cv::gimpl::Island>().island);
EXPECT_NE("isl0", gm.metadata(tmp1_nh).get<cv::gimpl::Island>().island);
EXPECT_NE("isl1", gm.metadata(tmp1_nh).get<cv::gimpl::Island>().island);
// FIXME: Add a test with same graph for Fusion and check GIslandModel
}
TEST_F(ComplexIslands, DistinictIslandsWithSameName)
{
// isl0
// ...........................
// (in0) -> Not -> (tmp0) --> Add ---------> (tmp2) --> AddC -------> (out0)
// :............ ........^...: ^
// ... : :
// (in1) -> Blur -> (tmp1) ----'--> Sum ----> (scl0) ----'
// : isl0
// : ..............................
// `------------> Median -> (tmp3) --> Blur -------> (out1)
// :............................:
cv::gapi::island("isl0", cv::GIn(in[0], tmp[1]), cv::GOut(tmp[2]));
cv::gapi::island("isl0", cv::GIn(tmp[1]), cv::GOut(out[1]));
auto cc = cv::GComputation(cv::GIn(in[0], in[1]), cv::GOut(out[0], out[1]));
EXPECT_ANY_THROW(cc.compile(cv::GMatDesc{CV_8U,1,{640,480}},
cv::GMatDesc{CV_8U,1,{640,480}}));
}
TEST_F(ComplexIslands, FullGraph)
{
cv::gapi::island("isl0", cv::GIn(in[0], in[1]), cv::GOut(out[0], out[1]));
auto cc = cv::GComputation(cv::GIn(in[0], in[1]), cv::GOut(out[0], out[1]))
.compile(cv::GMatDesc{CV_8U,1,{640,480}},
cv::GMatDesc{CV_8U,1,{640,480}});
const auto &gm = cc.priv().model();
std::vector<ade::NodeHandle> handles_inside = {
cv::gimpl::GModel::dataNodeOf(gm, tmp[0]),
cv::gimpl::GModel::dataNodeOf(gm, tmp[1]),
cv::gimpl::GModel::dataNodeOf(gm, tmp[2]),
cv::gimpl::GModel::dataNodeOf(gm, tmp[3]),
cv::gimpl::GModel::dataNodeOf(gm, scl),
};
std::vector<ade::NodeHandle> handles_outside = {
cv::gimpl::GModel::dataNodeOf(gm, in[0]),
cv::gimpl::GModel::dataNodeOf(gm, in[1]),
cv::gimpl::GModel::dataNodeOf(gm, out[0]),
cv::gimpl::GModel::dataNodeOf(gm, out[1]),
};
for (auto nh_inside : handles_inside)
{
EXPECT_EQ("isl0", gm.metadata(nh_inside).get<cv::gimpl::Island>().island);
}
for (auto nh_outside : handles_outside)
{
EXPECT_FALSE(gm.metadata(nh_outside).contains<cv::gimpl::Island>());
}
}
TEST_F(ComplexIslands, ViaScalar)
{
//
// .........................................#internal0.
// (in0) -> Not -> (tmp0) --> Add ---------> (tmp2) --> AddC -------> (out0)
// :....................^.........................^...:
// : :
// .....................:.........(isl0). :
// (in1) -> Blur -> (tmp1) ----'--> Sum ----> (scl0) ----'
// :..........:.........................:
// :
// : ..................#internal1.
// `------------> Median -> (tmp3) --> Blur -------> (out1)
// :...........................:
cv::gapi::island("isl0", cv::GIn(in[1]), cv::GOut(scl));
auto cc = cv::GComputation(cv::GIn(in[0], in[1]), cv::GOut(out[0], out[1]))
.compile(cv::GMatDesc{CV_8U,1,{640,480}},
cv::GMatDesc{CV_8U,1,{640,480}});
const auto &gm = cc.priv().model();
const auto tmp0_nh = cv::gimpl::GModel::dataNodeOf(gm, tmp[0]);
const auto tmp1_nh = cv::gimpl::GModel::dataNodeOf(gm, tmp[1]);
const auto tmp2_nh = cv::gimpl::GModel::dataNodeOf(gm, tmp[2]);
const auto tmp3_nh = cv::gimpl::GModel::dataNodeOf(gm, tmp[3]);
EXPECT_NE("isl0", gm.metadata(tmp0_nh).get<cv::gimpl::Island>().island); // <internal>
EXPECT_EQ("isl0", gm.metadata(tmp1_nh).get<cv::gimpl::Island>().island); // isl0
EXPECT_NE("isl0", gm.metadata(tmp2_nh).get<cv::gimpl::Island>().island); // <internal>
EXPECT_NE("isl0", gm.metadata(tmp3_nh).get<cv::gimpl::Island>().island); // <internal>
std::vector<ade::NodeHandle> handles_outside = {
cv::gimpl::GModel::dataNodeOf(gm, in[0]),
cv::gimpl::GModel::dataNodeOf(gm, in[1]),
cv::gimpl::GModel::dataNodeOf(gm, scl),
cv::gimpl::GModel::dataNodeOf(gm, out[0]),
cv::gimpl::GModel::dataNodeOf(gm, out[1]),
};
for (auto nh_outside : handles_outside)
{
EXPECT_FALSE(gm.metadata(nh_outside).contains<cv::gimpl::Island>());
}
}
TEST_F(ComplexIslands, BorderDataIsland)
{
// .................................(isl0)..
// : :
// (in0) -> Not -> (tmp0) --> Add ---------> (tmp2) --> AddC -------> (out0)
// : ^ : ^
// : : : :
// (in1) -> Blur -> (tmp1) ----'--> Sum ----> (scl0) ----'
// :...........:...........................:
// : : :
// : : :.........................................(isl1)..
// : `------------> Median -> (tmp3) --> Blur -------> (out1)
// : :
// :......................................................:
cv::gapi::island("isl0", cv::GIn(in[0], in[1]), cv::GOut(tmp[2], scl));
cv::gapi::island("isl1", cv::GIn(tmp[1]), cv::GOut(out[1]));
auto cc = cv::GComputation(cv::GIn(in[0], in[1]), cv::GOut(out[0], out[1]))
.compile(cv::GMatDesc{CV_8U,1,{640,480}},
cv::GMatDesc{CV_8U,1,{640,480}});
const auto &gm = cc.priv().model();
const auto in0_nh = cv::gimpl::GModel::dataNodeOf(gm, in[0]);
const auto in1_nh = cv::gimpl::GModel::dataNodeOf(gm, in[1]);
const auto tmp0_nh = cv::gimpl::GModel::dataNodeOf(gm, tmp[0]);
const auto tmp1_nh = cv::gimpl::GModel::dataNodeOf(gm, tmp[1]);
const auto tmp2_nh = cv::gimpl::GModel::dataNodeOf(gm, tmp[2]);
const auto tmp3_nh = cv::gimpl::GModel::dataNodeOf(gm, tmp[3]);
const auto scl_nh = cv::gimpl::GModel::dataNodeOf(gm, scl);
const auto out0_nh = cv::gimpl::GModel::dataNodeOf(gm, out[0]);
const auto out1_nh = cv::gimpl::GModel::dataNodeOf(gm, out[1]);
// Check handles inside isl0
EXPECT_EQ("isl0", gm.metadata(tmp0_nh).get<cv::gimpl::Island>().island);
EXPECT_EQ("isl0", gm.metadata(tmp1_nh).get<cv::gimpl::Island>().island);
// ^^^ Important - tmp1 is assigned to isl0, not isl1
// Check handles inside isl1
EXPECT_EQ("isl1", gm.metadata(tmp3_nh).get<cv::gimpl::Island>().island);
// Check outside handles
EXPECT_FALSE(gm.metadata(in0_nh) .contains<cv::gimpl::Island>());
EXPECT_FALSE(gm.metadata(in1_nh) .contains<cv::gimpl::Island>());
EXPECT_FALSE(gm.metadata(tmp2_nh).contains<cv::gimpl::Island>());
EXPECT_FALSE(gm.metadata(scl_nh) .contains<cv::gimpl::Island>());
EXPECT_FALSE(gm.metadata(out0_nh).contains<cv::gimpl::Island>());
EXPECT_FALSE(gm.metadata(out1_nh).contains<cv::gimpl::Island>());
}
TEST_F(ComplexIslands, IncompleteSpec)
{
// isl0
// ...........................
// (in0) -> Not -> (tmp0) --> Add ---------> (tmp2) --> AddC -------> (out0)
// :...........xxx.......^...: ^
// : :
// (in1) -> Blur -> (tmp1) ----'--> Sum ----> (scl0) ----'
// :
// :
// `------------> Median -> (tmp3) --> Blur -------> (out1)
//
// tmp1 is missing in the below spec
EXPECT_ANY_THROW(cv::gapi::island("isl0", cv::GIn(in[0]), cv::GOut(tmp[2])));
// empty range
EXPECT_ANY_THROW(cv::gapi::island("isl1", cv::GIn(tmp[2]), cv::GOut(tmp[2])));
}
TEST_F(ComplexIslands, InputOperationFromDifferentIslands)
{
// isl1
// ........................... ........
// (in0)--> Not -> (tmp0) --> Add :--------> (tmp2)-->: AddC : -------> (out0)
// :......................^..: : ^ :
// isl0 : : : :
// .......................:....................... : :
// (in1) :-> Blur -> (tmp1) ----'--> Sum ----> (scl0) ----- :
// :....................................................:
// isl0 :
// `------------> Median -> (tmp3) --> Blur -------> (out1)
//
cv::gapi::island("isl0", cv::GIn(in[1], tmp[2]), cv::GOut(out[0]));
cv::gapi::island("isl1", cv::GIn(in[0], tmp[1]), cv::GOut(tmp[2]));
auto cc = cv::GComputation(cv::GIn(in[0], in[1]), cv::GOut(out[0], out[1]))
.compile(cv::GMatDesc{CV_8U,1,{640,480}},
cv::GMatDesc{CV_8U,1,{640,480}});
const auto &gm = cc.priv().model();
const auto tmp0_nh = cv::gimpl::GModel::dataNodeOf(gm, tmp[0]);
const auto tmp1_nh = cv::gimpl::GModel::dataNodeOf(gm, tmp[1]);
const auto tmp2_nh = cv::gimpl::GModel::dataNodeOf(gm, tmp[2]);
EXPECT_EQ("isl1", gm.metadata(tmp0_nh).get<cv::gimpl::Island>().island);
EXPECT_EQ("isl0", gm.metadata(tmp1_nh).get<cv::gimpl::Island>().island);
EXPECT_FALSE(gm.metadata(tmp2_nh).contains<cv::gimpl::Island>());
}
TEST_F(ComplexIslands, NoWayBetweenNodes)
{
// (in0) -> Not -> (tmp0) --> Add ---------> (tmp2) --> AddC -------> (out0)
// ^ ^
// (in1) -> Blur -> (tmp1) ----'--> Sum ----> (scl0) ----'
// :
// `------------> Median -> (tmp3) --> Blur -------> (out1)
EXPECT_ANY_THROW(cv::gapi::island("isl0", cv::GIn(in[1]), cv::GOut(tmp[0])));
}
TEST_F(ComplexIslands, IslandsContainUnusedPart)
{
// Unused part of the graph
// x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x
// x x
// x(in0) -> Not -> (tmp0) --> Add ---------> (tmp2)---> AddC ---------> (out0) x
// x ^ ^ x
// x x x x x x x x x x x x x x x | x x | x
// | x | x
// ...... | x | x
// (in1) -> :Blur:----------> (tmp1) x-----> Sum ------> (scl0) x
// ...... : x x x x x x x x x x x x x x x x x x x x x x x x
// isl0
// :
// `------------> Median -> (tmp3) --> Blur -------> (out1)
cv::gapi::island("isl0", cv::GIn(in[1]), cv::GOut(scl));
auto cc = cv::GComputation(cv::GIn(in[1]), cv::GOut(out[1]))
.compile(cv::GMatDesc{CV_8U,1,{640,480}});
const auto &gm = cc.priv().model();
const auto tmp1_nh = cv::gimpl::GModel::dataNodeOf(gm, tmp[1]);
//The output 0 is not specified in the graph
//means that there will not be a node scl, so that tmp1 will not assign to the island
// FIXME Check that blur assigned to island using the function producerOf
// After merge islands fusion
EXPECT_FALSE(gm.metadata(tmp1_nh) .contains<cv::gimpl::Island>());
}
TEST_F(ComplexIslands, FullGraphInTwoIslands)
{
// isl0
// ..................................................
// (in0) -> :Not -> (tmp0) --> Add ---------> (tmp2) --> AddC: -------> (out0)
// ...................^.... ^ :
// ............... | : : :
// (in1) -> :Blur-> (tmp1):----'-->:Sum ----> (scl0) ----' :
// ........ | : ...........................
// isl1 : | :............................................
// : `------------> Median -> (tmp3) --> Blur ------->:(out1)
// ....................................................
cv::gapi::island("isl0", cv::GIn(in[0], tmp[1]), cv::GOut(out[0]));
cv::gapi::island("isl1", cv::GIn(in[1]), cv::GOut(out[1]));
auto cc = cv::GComputation(cv::GIn(in[0], in[1]), cv::GOut(out[0], out[1]))
.compile(cv::GMatDesc{CV_8U,1,{640,480}},
cv::GMatDesc{CV_8U,1,{640,480}});
const auto &gm = cc.priv().model();
const auto in0_nh = cv::gimpl::GModel::dataNodeOf(gm, in[0]);
const auto in1_nh = cv::gimpl::GModel::dataNodeOf(gm, in[1]);
const auto tmp0_nh = cv::gimpl::GModel::dataNodeOf(gm, tmp[0]);
const auto tmp1_nh = cv::gimpl::GModel::dataNodeOf(gm, tmp[1]);
const auto tmp2_nh = cv::gimpl::GModel::dataNodeOf(gm, tmp[2]);
const auto tmp3_nh = cv::gimpl::GModel::dataNodeOf(gm, tmp[3]);
const auto scl_nh = cv::gimpl::GModel::dataNodeOf(gm, scl);
const auto out0_nh = cv::gimpl::GModel::dataNodeOf(gm, out[0]);
const auto out1_nh = cv::gimpl::GModel::dataNodeOf(gm, out[1]);
// Check handles inside isl0
EXPECT_EQ("isl0", gm.metadata(tmp0_nh).get<cv::gimpl::Island>().island);
EXPECT_EQ("isl0", gm.metadata(tmp2_nh).get<cv::gimpl::Island>().island);
EXPECT_EQ("isl0", gm.metadata(scl_nh).get<cv::gimpl::Island>().island);
// Check handles inside isl1
EXPECT_EQ("isl1", gm.metadata(tmp1_nh).get<cv::gimpl::Island>().island);
EXPECT_EQ("isl1", gm.metadata(tmp3_nh).get<cv::gimpl::Island>().island);
// Check outside handles
EXPECT_FALSE(gm.metadata(in0_nh) .contains<cv::gimpl::Island>());
EXPECT_FALSE(gm.metadata(in1_nh) .contains<cv::gimpl::Island>());
EXPECT_FALSE(gm.metadata(out0_nh).contains<cv::gimpl::Island>());
EXPECT_FALSE(gm.metadata(out1_nh).contains<cv::gimpl::Island>());
}
TEST_F(ComplexIslands, OnlyOperationsAssignedToIslands)
{
cv::gapi::island("isl0", cv::GIn(in[1]), cv::GOut(tmp[1]));
cv::gapi::island("isl1", cv::GIn(tmp[1]), cv::GOut(scl));
cv::gapi::island("isl2", cv::GIn(scl, tmp[2]), cv::GOut(out[0]));
cv::gapi::island("isl3", cv::GIn(in[0]), cv::GOut(tmp[0]));
cv::gapi::island("isl4", cv::GIn(tmp[0], tmp[1]), cv::GOut(tmp[2]));
cv::gapi::island("isl5", cv::GIn(tmp[1]), cv::GOut(tmp[3]));
cv::gapi::island("isl6", cv::GIn(tmp[3]), cv::GOut(out[1]));
auto cc = cv::GComputation(cv::GIn(in[0], in[1]), cv::GOut(out[0], out[1]))
.compile(cv::GMatDesc{CV_8U,1,{640,480}},
cv::GMatDesc{CV_8U,1,{640,480}});
const auto &gm = cc.priv().model();
//FIXME: Check that operation handles are really assigned to isl0..isl6
const auto in0_nh = cv::gimpl::GModel::dataNodeOf(gm, in[0]);
const auto in1_nh = cv::gimpl::GModel::dataNodeOf(gm, in[1]);
const auto tmp0_nh = cv::gimpl::GModel::dataNodeOf(gm, tmp[0]);
const auto tmp1_nh = cv::gimpl::GModel::dataNodeOf(gm, tmp[1]);
const auto tmp2_nh = cv::gimpl::GModel::dataNodeOf(gm, tmp[2]);
const auto tmp3_nh = cv::gimpl::GModel::dataNodeOf(gm, tmp[3]);
const auto scl_nh = cv::gimpl::GModel::dataNodeOf(gm, scl);
const auto out0_nh = cv::gimpl::GModel::dataNodeOf(gm, out[0]);
const auto out1_nh = cv::gimpl::GModel::dataNodeOf(gm, out[1]);
EXPECT_FALSE(gm.metadata(in0_nh) .contains<cv::gimpl::Island>());
EXPECT_FALSE(gm.metadata(in1_nh) .contains<cv::gimpl::Island>());
EXPECT_FALSE(gm.metadata(tmp0_nh) .contains<cv::gimpl::Island>());
EXPECT_FALSE(gm.metadata(tmp1_nh) .contains<cv::gimpl::Island>());
EXPECT_FALSE(gm.metadata(tmp2_nh) .contains<cv::gimpl::Island>());
EXPECT_FALSE(gm.metadata(tmp3_nh) .contains<cv::gimpl::Island>());
EXPECT_FALSE(gm.metadata(scl_nh) .contains<cv::gimpl::Island>());
EXPECT_FALSE(gm.metadata(out0_nh).contains<cv::gimpl::Island>());
EXPECT_FALSE(gm.metadata(out1_nh).contains<cv::gimpl::Island>());
}
namespace
{
struct IslandStructureWithGArray
{
GIntArray in, out;
GMat tmp;
IslandStructureWithGArray()
{
tmp = CreateMatWithDiag::on(in);
out = Mat2Array::on(tmp);
}
};
struct IslandsWithGArray: public ::testing::Test, public IslandStructureWithGArray {};
} // namespace
TEST_F(IslandsWithGArray, IslandWithGArrayAsInput)
{
cv::gapi::island("isl0", cv::GIn(in), cv::GOut(tmp));
const auto pkg = cv::gapi::kernels<CreateMatWithDiagImpl, Mat2ArrayImpl>();
auto cc = cv::GComputation(cv::GIn(in), GOut(out)).compile(cv::empty_array_desc(), cv::compile_args(pkg));
const auto &gm = cc.priv().model();
const auto in_nh = cv::gimpl::GModel::dataNodeOf(gm, in.strip());
const auto out_nh = cv::gimpl::GModel::dataNodeOf(gm, out.strip());
const auto tmp_nh = cv::gimpl::GModel::dataNodeOf(gm, tmp);
GAPI_Assert(tmp_nh->inNodes().size() == 1);
const auto create_diag_mat_nh = tmp_nh->inNodes().front();
EXPECT_EQ("isl0", gm.metadata(create_diag_mat_nh).get<cv::gimpl::Island>().island);
EXPECT_FALSE(gm.metadata(in_nh) .contains<cv::gimpl::Island>());
EXPECT_FALSE(gm.metadata(out_nh) .contains<cv::gimpl::Island>());
EXPECT_FALSE(gm.metadata(tmp_nh) .contains<cv::gimpl::Island>());
}
TEST_F(IslandsWithGArray, IslandWithGArrayAsOutput)
{
cv::gapi::island("isl0", cv::GIn(tmp), cv::GOut(out));
const auto pkg = cv::gapi::kernels<CreateMatWithDiagImpl, Mat2ArrayImpl>();
auto cc = cv::GComputation(cv::GIn(in), GOut(out)).compile(cv::empty_array_desc(), cv::compile_args(pkg));
const auto &gm = cc.priv().model();
const auto in_nh = cv::gimpl::GModel::dataNodeOf(gm, in.strip());
const auto out_nh = cv::gimpl::GModel::dataNodeOf(gm, out.strip());
const auto tmp_nh = cv::gimpl::GModel::dataNodeOf(gm, tmp);
GAPI_Assert(tmp_nh->inNodes().size() == 1);
const auto mat2array_nh = out_nh->inNodes().front();
EXPECT_EQ("isl0", gm.metadata(mat2array_nh).get<cv::gimpl::Island>().island);
EXPECT_FALSE(gm.metadata(in_nh) .contains<cv::gimpl::Island>());
EXPECT_FALSE(gm.metadata(out_nh) .contains<cv::gimpl::Island>());
EXPECT_FALSE(gm.metadata(tmp_nh) .contains<cv::gimpl::Island>());
}
////////////////////////////////////////////////////////////////////////////////
// Wrong input tests on island name
//
namespace
{
struct CheckName : public TestWithParam<std::tuple<bool, const char*> >,
public PlainIslandsFixture
{
void assignIsland(const std::string &s)
{
cv::gapi::island(s, cv::GIn(tmp[0]), cv::GOut(tmp[2]));
};
};
TEST_P(CheckName, Test)
{
bool correct = false;
const char *name = "";
std::tie(correct, name) = GetParam();
if (correct) EXPECT_NO_THROW(assignIsland(name));
else EXPECT_ANY_THROW(assignIsland(name));
}
} // namespace
INSTANTIATE_TEST_CASE_P(IslandName, CheckName,
Values(std::make_tuple(true, "name"),
std::make_tuple(true, " name "),
std::make_tuple(true, " n a m e "),
std::make_tuple(true, " 123 $$ %%"),
std::make_tuple(true, ".: -"),
std::make_tuple(false, ""),
std::make_tuple(false, " "),
std::make_tuple(false, " \t "),
std::make_tuple(false, " \t \t ")));
// FIXME: add <internal> test on unrollExpr() use for islands
} // opencv_test
Reference in New Issue View Git Blame Copy Permalink