init - 初始化项目
This commit is contained in:
Lee Nony
654
modules/gapi/test/internal/gapi_int_island_tests.cpp
Normal file
654
modules/gapi/test/internal/gapi_int_island_tests.cpp
Normal file
@@ -0,0 +1,654 @@
|
||||
// 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
Block a user