CoCalc -- gapi_int_island

GitHub Repository: Tetragramm/opencv
Path: blob/master/modules/gapi/test/internal/gapi_int_island_tests.cpp
¹⁶³³⁹ views
1
// This file is part of OpenCV project.
2
// It is subject to the license terms in the LICENSE file found in the top-level directory
3
// of this distribution and at http://opencv.org/license.html.
4
//
5
// Copyright (C) 2018 Intel Corporation
6

7

8
#include "test_precomp.hpp"
9

10
#include "compiler/gmodel.hpp"
11
#include "compiler/gcompiled_priv.hpp"
12

13
namespace opencv_test
14
{
15

16
////////////////////////////////////////////////////////////////////////////////
17
// Tests on a plain graph
18
//
19
// (in) -> Blur1 -> (tmp0) -> Blur2 -> (tmp1) -> Blur3 -> (tmp2) -> Blur4 -> (out)
20
//
21
namespace
22
{
23
    struct PlainIslandsFixture
24
    {
25
        cv::GMat in;
26
        cv::GMat tmp[3];
27
        cv::GMat out;
28

29
        PlainIslandsFixture()
30
        {
31
            tmp[0] = cv::gapi::boxFilter(in,     -1, cv::Size(3,3));
32
            tmp[1] = cv::gapi::boxFilter(tmp[0], -1, cv::Size(3,3));
33
            tmp[2] = cv::gapi::boxFilter(tmp[1], -1, cv::Size(3,3));
34
            out    = cv::gapi::boxFilter(tmp[2], -1, cv::Size(3,3));
35
        }
36
    };
37

38
    struct Islands: public ::testing::Test, public PlainIslandsFixture {};
39

40
    using GIntArray = GArray<int>;
41

42
    G_TYPED_KERNEL(CreateMatWithDiag, <GMat(GIntArray)>, "test.array.create_mat_with_diag")
43
    {
44
        static GMatDesc outMeta(const GArrayDesc&) { return cv::GMatDesc{CV_32S, 1,{3, 3}}; }
45
    };
46

47
    GAPI_OCV_KERNEL(CreateMatWithDiagImpl, CreateMatWithDiag)
48
    {
49
        static void run(const std::vector<int> &in, cv::Mat& out)
50
        {
51
            auto size = static_cast<int>(in.size());
52
            out = Mat::zeros(size, size, CV_32SC1);
53
            for(int i = 0; i < out.rows; i++)
54
            {
55
                auto* row = out.ptr<int>(i);
56
                row[i] = in[i];
57
            }
58
        }
59
    };
60

61
    G_TYPED_KERNEL(Mat2Array, <GIntArray(GMat)>, "test.array.mat2array")
62
    {
63
        static GArrayDesc outMeta(const GMatDesc&) { return empty_array_desc(); }
64
    };
65

66
    GAPI_OCV_KERNEL(Mat2ArrayImpl, Mat2Array)
67
    {
68
        static void run(const cv::Mat& in, std::vector<int> &out)
69
        {
70
            GAPI_Assert(in.depth() == CV_32S && in.isContinuous());
71
            out.reserve(in.cols * in.rows);
72
            out.assign((int*)in.datastart, (int*)in.dataend);
73
        }
74
    };
75
}
76

77
TEST_F(Islands, SmokeTest)
78
{
79
    // (in) -> Blur1 -> (tmp0) -> Blur2 -> (tmp1) -> Blur3 -> (tmp2) -> Blur4 -> (out)
80
    //                         :        "test"             :
81
    //                         :<------------------------->:
82
    cv::gapi::island("test", cv::GIn(tmp[0]), cv::GOut(tmp[2]));
83
    auto cc = cv::GComputation(in, out).compile(cv::GMatDesc{CV_8U,1,{640,480}});
84

85
    const auto &gm = cc.priv().model();
86
    const auto tmp0_nh = cv::gimpl::GModel::dataNodeOf(gm, tmp[0]);
87
    const auto tmp1_nh = cv::gimpl::GModel::dataNodeOf(gm, tmp[1]);
88
    const auto tmp2_nh = cv::gimpl::GModel::dataNodeOf(gm, tmp[2]);
89

90
    // tmp1 and tmp3 is not a part of any island
91
    EXPECT_FALSE(gm.metadata(tmp0_nh).contains<cv::gimpl::Island>());
92
    EXPECT_FALSE(gm.metadata(tmp2_nh).contains<cv::gimpl::Island>());
93

94
    // tmp2 is part of "test" island
95
    EXPECT_TRUE(gm.metadata(tmp1_nh).contains<cv::gimpl::Island>());
96
    EXPECT_EQ("test", gm.metadata(tmp1_nh).get<cv::gimpl::Island>().island);
97
}
98

99
TEST_F(Islands, TwoIslands)
100
{
101
    // (in) -> Blur1 -> (tmp0) -> Blur2 -> (tmp1) -> Blur3 -> (tmp2) -> Blur4 -> (out)
102
    //       :  "test1"                     :  : "test2"                          :
103
    //       :<---------------------------->:  :<--------------------------------->
104
    EXPECT_NO_THROW(cv::gapi::island("test1", cv::GIn(in),     cv::GOut(tmp[1])));
105
    EXPECT_NO_THROW(cv::gapi::island("test2", cv::GIn(tmp[1]), cv::GOut(out)));
106

107
    auto cc = cv::GComputation(in, out).compile(cv::GMatDesc{CV_8U,1,{640,480}});
108
    const auto &gm = cc.priv().model();
109
    const auto in_nh   = cv::gimpl::GModel::dataNodeOf(gm, in);
110
    const auto tmp0_nh = cv::gimpl::GModel::dataNodeOf(gm, tmp[0]);
111
    const auto tmp1_nh = cv::gimpl::GModel::dataNodeOf(gm, tmp[1]);
112
    const auto tmp2_nh = cv::gimpl::GModel::dataNodeOf(gm, tmp[2]);
113
    const auto out_nh  = cv::gimpl::GModel::dataNodeOf(gm, out);
114

115
    // Only tmp0 and tmp2 should be listed in islands.
116
    EXPECT_TRUE (gm.metadata(tmp0_nh).contains<cv::gimpl::Island>());
117
    EXPECT_TRUE (gm.metadata(tmp2_nh).contains<cv::gimpl::Island>());
118
    EXPECT_FALSE(gm.metadata(in_nh)  .contains<cv::gimpl::Island>());
119
    EXPECT_FALSE(gm.metadata(tmp1_nh).contains<cv::gimpl::Island>());
120
    EXPECT_FALSE(gm.metadata(out_nh) .contains<cv::gimpl::Island>());
121

122
    EXPECT_EQ("test1", gm.metadata(tmp0_nh).get<cv::gimpl::Island>().island);
123
    EXPECT_EQ("test2", gm.metadata(tmp2_nh).get<cv::gimpl::Island>().island);
124
}
125

126
// FIXME: Disabled since currently merge procedure merges two into one
127
// succesfully
128
TEST_F(Islands, DISABLED_Two_Islands_With_Same_Name_Should_Fail)
129
{
130
    // (in) -> Blur1 -> (tmp0) -> Blur2 -> (tmp1) -> Blur3 -> (tmp2) -> Blur4 -> (out)
131
    //       :  "test1"                     :  : "test1"                          :
132
    //       :<---------------------------->:  :<--------------------------------->
133

134
    EXPECT_NO_THROW(cv::gapi::island("test1", cv::GIn(in),     cv::GOut(tmp[1])));
135
    EXPECT_NO_THROW(cv::gapi::island("test1", cv::GIn(tmp[1]), cv::GOut(out)));
136

137
    EXPECT_ANY_THROW(cv::GComputation(in, out).compile(cv::GMatDesc{CV_8U,1,{640,480}}));
138
}
139

140

141
// (in) -> Blur1 -> (tmp0) -> Blur2 -> (tmp1) -> Blur3 -> (tmp2) -> Blur4 -> (out)
142
//       :          "test1":            :              :
143
//       :<----------------:----------->:              :
144
//                         :                           :
145
//                         :        "test2"            :
146
//                         :<------------------------->:
147
TEST_F(Islands, OverlappingIslands1)
148
{
149
    EXPECT_NO_THROW (cv::gapi::island("test1", cv::GIn(in),     cv::GOut(tmp[1])));
150
    EXPECT_ANY_THROW(cv::gapi::island("test2", cv::GIn(tmp[0]), cv::GOut(tmp[2])));
151
}
152

153
TEST_F(Islands, OverlappingIslands2)
154
{
155
    EXPECT_NO_THROW (cv::gapi::island("test2", cv::GIn(tmp[0]), cv::GOut(tmp[2])));
156
    EXPECT_ANY_THROW(cv::gapi::island("test1", cv::GIn(in),     cv::GOut(tmp[1])));
157
}
158

159
////////////////////////////////////////////////////////////////////////////////
160
// Tests on a complex graph
161
//
162
// (in0) -> Not  -> (tmp0) --> Add ---------> (tmp2) --> AddC -------> (out0)
163
//                             ^                         ^
164
// (in1) -> Blur -> (tmp1) ----'--> Sum ----> (scl0) ----'
165
//                   :
166
//                   `------------> Median -> (tmp3) --> Blur -------> (out1)
167
//
168
namespace
169
{
170
    struct ComplexIslandsFixture
171
    {
172
        cv::GMat    in[2];
173
        cv::GMat    tmp[4];
174
        cv::GScalar scl;
175
        cv::GMat    out[2];
176

177
        ComplexIslandsFixture()
178
        {
179
            tmp[0] = cv::gapi::bitwise_not(in[0]);
180
            tmp[1] = cv::gapi::boxFilter(in[1], -1, cv::Size(3,3));
181
            tmp[2] = tmp[0] + tmp[1]; // FIXME: handle tmp[2] = tmp[0]+tmp[2] typo
182
            scl    = cv::gapi::sum(tmp[1]);
183
            tmp[3] = cv::gapi::medianBlur(tmp[1], 3);
184
            out[0] = tmp[2] + scl;
185
            out[1] = cv::gapi::boxFilter(tmp[3], -1, cv::Size(3,3));
186
        }
187
    };
188

189
    struct ComplexIslands: public ::testing::Test, public ComplexIslandsFixture {};
190
} // namespace
191

192
TEST_F(ComplexIslands, SmokeTest)
193
{
194
    //       isl0                                          #internal1
195
    //       ...........................                   ........
196
    // (in0) -> Not  -> (tmp0) --> Add ---------> (tmp2) --> AddC -------> (out0)
197
    //       :............ ........^...:                   :.^....:
198
    //                   ...       :                         :
199
    // (in1) -> Blur -> (tmp1) ----'--> Sum ----> (scl0) ----'
200
    //                   :                                     isl1
201
    //                   :           ..............................
202
    //                   `------------> Median -> (tmp3) --> Blur -------> (out1)
203
    //                               :............................:
204

205
    cv::gapi::island("isl0", cv::GIn(in[0], tmp[1]),  cv::GOut(tmp[2]));
206
    cv::gapi::island("isl1", cv::GIn(tmp[1]), cv::GOut(out[1]));
207
    auto cc = cv::GComputation(cv::GIn(in[0], in[1]), cv::GOut(out[0], out[1]))
208
        .compile(cv::GMatDesc{CV_8U,1,{640,480}},
209
                 cv::GMatDesc{CV_8U,1,{640,480}});
210
    const auto &gm = cc.priv().model();
211
    const auto in0_nh  = cv::gimpl::GModel::dataNodeOf(gm, in[0]);
212
    const auto in1_nh  = cv::gimpl::GModel::dataNodeOf(gm, in[1]);
213
    const auto tmp0_nh = cv::gimpl::GModel::dataNodeOf(gm, tmp[0]);
214
    const auto tmp1_nh = cv::gimpl::GModel::dataNodeOf(gm, tmp[1]);
215
    const auto tmp2_nh = cv::gimpl::GModel::dataNodeOf(gm, tmp[2]);
216
    const auto tmp3_nh = cv::gimpl::GModel::dataNodeOf(gm, tmp[3]);
217
    const auto scl_nh  = cv::gimpl::GModel::dataNodeOf(gm, scl);
218
    const auto out0_nh = cv::gimpl::GModel::dataNodeOf(gm, out[0]);
219
    const auto out1_nh = cv::gimpl::GModel::dataNodeOf(gm, out[1]);
220

221
    // tmp0, tmp3 are in islands, others are not
222
    EXPECT_TRUE(gm.metadata(tmp0_nh) .contains<cv::gimpl::Island>()); // isl0
223
    EXPECT_TRUE(gm.metadata(tmp3_nh) .contains<cv::gimpl::Island>()); // isl1
224
    EXPECT_FALSE(gm.metadata(in0_nh) .contains<cv::gimpl::Island>()); // (input is never fused)
225
    EXPECT_FALSE(gm.metadata(in1_nh) .contains<cv::gimpl::Island>()); // (input is never fused)
226
    EXPECT_TRUE (gm.metadata(tmp1_nh).contains<cv::gimpl::Island>()); // <internal island>
227
    EXPECT_FALSE(gm.metadata(tmp2_nh).contains<cv::gimpl::Island>()); // #not fused as cycle-causing#
228
    EXPECT_FALSE(gm.metadata(scl_nh) .contains<cv::gimpl::Island>()); // #not fused as cycle-causing#
229
    EXPECT_FALSE(gm.metadata(out0_nh).contains<cv::gimpl::Island>()); // (output is never fused)
230
    EXPECT_FALSE(gm.metadata(out1_nh).contains<cv::gimpl::Island>()); // (output is never fused)
231

232
    EXPECT_EQ("isl0", gm.metadata(tmp0_nh).get<cv::gimpl::Island>().island);
233
    EXPECT_EQ("isl1", gm.metadata(tmp3_nh).get<cv::gimpl::Island>().island);
234

235
    EXPECT_NE("isl0", gm.metadata(tmp1_nh).get<cv::gimpl::Island>().island);
236
    EXPECT_NE("isl1", gm.metadata(tmp1_nh).get<cv::gimpl::Island>().island);
237

238
    // FIXME: Add a test with same graph for Fusion and check GIslandModel
239
}
240

241
TEST_F(ComplexIslands, DistinictIslandsWithSameName)
242
{
243
    //       isl0
244
    //       ...........................
245
    // (in0) -> Not  -> (tmp0) --> Add ---------> (tmp2) --> AddC -------> (out0)
246
    //       :............ ........^...:                     ^
247
    //                   ...       :                         :
248
    // (in1) -> Blur -> (tmp1) ----'--> Sum ----> (scl0) ----'
249
    //                   :                                     isl0
250
    //                   :           ..............................
251
    //                   `------------> Median -> (tmp3) --> Blur -------> (out1)
252
    //                               :............................:
253

254
    cv::gapi::island("isl0", cv::GIn(in[0], tmp[1]),  cv::GOut(tmp[2]));
255
    cv::gapi::island("isl0", cv::GIn(tmp[1]), cv::GOut(out[1]));
256

257
    auto cc = cv::GComputation(cv::GIn(in[0], in[1]), cv::GOut(out[0], out[1]));
258

259
    EXPECT_ANY_THROW(cc.compile(cv::GMatDesc{CV_8U,1,{640,480}},
260
                                cv::GMatDesc{CV_8U,1,{640,480}}));
261
}
262

263
TEST_F(ComplexIslands, FullGraph)
264
{
265
    cv::gapi::island("isl0",   cv::GIn(in[0], in[1]), cv::GOut(out[0], out[1]));
266
    auto cc = cv::GComputation(cv::GIn(in[0], in[1]), cv::GOut(out[0], out[1]))
267
        .compile(cv::GMatDesc{CV_8U,1,{640,480}},
268
                 cv::GMatDesc{CV_8U,1,{640,480}});
269
    const auto &gm = cc.priv().model();
270
    std::vector<ade::NodeHandle> handles_inside = {
271
        cv::gimpl::GModel::dataNodeOf(gm, tmp[0]),
272
        cv::gimpl::GModel::dataNodeOf(gm, tmp[1]),
273
        cv::gimpl::GModel::dataNodeOf(gm, tmp[2]),
274
        cv::gimpl::GModel::dataNodeOf(gm, tmp[3]),
275
        cv::gimpl::GModel::dataNodeOf(gm, scl),
276
    };
277
    std::vector<ade::NodeHandle> handles_outside = {
278
        cv::gimpl::GModel::dataNodeOf(gm, in[0]),
279
        cv::gimpl::GModel::dataNodeOf(gm, in[1]),
280
        cv::gimpl::GModel::dataNodeOf(gm, out[0]),
281
        cv::gimpl::GModel::dataNodeOf(gm, out[1]),
282
    };
283

284
    for (auto nh_inside : handles_inside)
285
    {
286
        EXPECT_EQ("isl0", gm.metadata(nh_inside).get<cv::gimpl::Island>().island);
287
    }
288
    for (auto nh_outside : handles_outside)
289
    {
290
        EXPECT_FALSE(gm.metadata(nh_outside).contains<cv::gimpl::Island>());
291
    }
292
}
293

294
TEST_F(ComplexIslands, ViaScalar)
295
{
296
    //
297
    //        .........................................#internal0.
298
    // (in0) -> Not  -> (tmp0) --> Add ---------> (tmp2) --> AddC -------> (out0)
299
    //        :....................^.........................^...:
300
    //                             :                         :
301
    //        .....................:.........(isl0).         :
302
    // (in1) -> Blur -> (tmp1) ----'--> Sum ----> (scl0) ----'
303
    //        :..........:.........................:
304
    //                   :
305
    //                   :            ..................#internal1.
306
    //                   `------------> Median -> (tmp3) --> Blur -------> (out1)
307
    //                                :...........................:
308

309
    cv::gapi::island("isl0",   cv::GIn(in[1]), cv::GOut(scl));
310
    auto cc = cv::GComputation(cv::GIn(in[0], in[1]), cv::GOut(out[0], out[1]))
311
        .compile(cv::GMatDesc{CV_8U,1,{640,480}},
312
                 cv::GMatDesc{CV_8U,1,{640,480}});
313
    const auto &gm = cc.priv().model();
314

315
    const auto tmp0_nh = cv::gimpl::GModel::dataNodeOf(gm, tmp[0]);
316
    const auto tmp1_nh = cv::gimpl::GModel::dataNodeOf(gm, tmp[1]);
317
    const auto tmp2_nh = cv::gimpl::GModel::dataNodeOf(gm, tmp[2]);
318
    const auto tmp3_nh = cv::gimpl::GModel::dataNodeOf(gm, tmp[3]);
319

320
    EXPECT_NE("isl0", gm.metadata(tmp0_nh).get<cv::gimpl::Island>().island); // <internal>
321
    EXPECT_EQ("isl0", gm.metadata(tmp1_nh).get<cv::gimpl::Island>().island); // isl0
322
    EXPECT_NE("isl0", gm.metadata(tmp2_nh).get<cv::gimpl::Island>().island); // <internal>
323
    EXPECT_NE("isl0", gm.metadata(tmp3_nh).get<cv::gimpl::Island>().island); // <internal>
324

325
    std::vector<ade::NodeHandle> handles_outside = {
326
        cv::gimpl::GModel::dataNodeOf(gm, in[0]),
327
        cv::gimpl::GModel::dataNodeOf(gm, in[1]),
328
        cv::gimpl::GModel::dataNodeOf(gm, scl),
329
        cv::gimpl::GModel::dataNodeOf(gm, out[0]),
330
        cv::gimpl::GModel::dataNodeOf(gm, out[1]),
331
    };
332
    for (auto nh_outside : handles_outside)
333
    {
334
        EXPECT_FALSE(gm.metadata(nh_outside).contains<cv::gimpl::Island>());
335
    }
336
}
337

338
TEST_F(ComplexIslands, BorderDataIsland)
339
{
340
    //       .................................(isl0)..
341
    //       :                                       :
342
    // (in0) -> Not  -> (tmp0) --> Add ---------> (tmp2) --> AddC -------> (out0)
343
    //       :                     ^                 :       ^
344
    //       :                     :                 :       :
345
    // (in1) -> Blur -> (tmp1) ----'--> Sum ----> (scl0) ----'
346
    //       :...........:...........................:
347
    //                :  :  :
348
    //                :  :  :.........................................(isl1)..
349
    //                :  `------------> Median -> (tmp3) --> Blur -------> (out1)
350
    //                :                                                      :
351
    //                :......................................................:
352

353
    cv::gapi::island("isl0", cv::GIn(in[0],  in[1]), cv::GOut(tmp[2], scl));
354
    cv::gapi::island("isl1", cv::GIn(tmp[1]),        cv::GOut(out[1]));
355

356
    auto cc = cv::GComputation(cv::GIn(in[0], in[1]), cv::GOut(out[0], out[1]))
357
        .compile(cv::GMatDesc{CV_8U,1,{640,480}},
358
                 cv::GMatDesc{CV_8U,1,{640,480}});
359
    const auto &gm = cc.priv().model();
360
    const auto in0_nh  = cv::gimpl::GModel::dataNodeOf(gm, in[0]);
361
    const auto in1_nh  = cv::gimpl::GModel::dataNodeOf(gm, in[1]);
362
    const auto tmp0_nh = cv::gimpl::GModel::dataNodeOf(gm, tmp[0]);
363
    const auto tmp1_nh = cv::gimpl::GModel::dataNodeOf(gm, tmp[1]);
364
    const auto tmp2_nh = cv::gimpl::GModel::dataNodeOf(gm, tmp[2]);
365
    const auto tmp3_nh = cv::gimpl::GModel::dataNodeOf(gm, tmp[3]);
366
    const auto scl_nh  = cv::gimpl::GModel::dataNodeOf(gm, scl);
367
    const auto out0_nh = cv::gimpl::GModel::dataNodeOf(gm, out[0]);
368
    const auto out1_nh = cv::gimpl::GModel::dataNodeOf(gm, out[1]);
369

370
    // Check handles inside isl0
371
    EXPECT_EQ("isl0", gm.metadata(tmp0_nh).get<cv::gimpl::Island>().island);
372
    EXPECT_EQ("isl0", gm.metadata(tmp1_nh).get<cv::gimpl::Island>().island);
373
    // ^^^ Important - tmp1 is assigned to isl0, not isl1
374

375
    // Check handles inside isl1
376
    EXPECT_EQ("isl1", gm.metadata(tmp3_nh).get<cv::gimpl::Island>().island);
377

378
    // Check outside handles
379
    EXPECT_FALSE(gm.metadata(in0_nh) .contains<cv::gimpl::Island>());
380
    EXPECT_FALSE(gm.metadata(in1_nh) .contains<cv::gimpl::Island>());
381
    EXPECT_FALSE(gm.metadata(tmp2_nh).contains<cv::gimpl::Island>());
382
    EXPECT_FALSE(gm.metadata(scl_nh) .contains<cv::gimpl::Island>());
383
    EXPECT_FALSE(gm.metadata(out0_nh).contains<cv::gimpl::Island>());
384
    EXPECT_FALSE(gm.metadata(out1_nh).contains<cv::gimpl::Island>());
385
}
386

387

388
TEST_F(ComplexIslands, IncompleteSpec)
389
{
390
    //       isl0
391
    //       ...........................
392
    // (in0) -> Not  -> (tmp0) --> Add ---------> (tmp2) --> AddC -------> (out0)
393
    //       :...........xxx.......^...:                     ^
394
    //                             :                         :
395
    // (in1) -> Blur -> (tmp1) ----'--> Sum ----> (scl0) ----'
396
    //                   :
397
    //                   :
398
    //                   `------------> Median -> (tmp3) --> Blur -------> (out1)
399
    //
400

401
    // tmp1 is missing in the below spec
402
    EXPECT_ANY_THROW(cv::gapi::island("isl0", cv::GIn(in[0]),  cv::GOut(tmp[2])));
403

404
    // empty range
405
    EXPECT_ANY_THROW(cv::gapi::island("isl1", cv::GIn(tmp[2]),  cv::GOut(tmp[2])));
406
}
407

408
TEST_F(ComplexIslands, InputOperationFromDifferentIslands)
409
{
410
    //       isl1
411
    //       ...........................                   ........
412
    // (in0)--> Not  -> (tmp0) --> Add :--------> (tmp2)-->: AddC : -------> (out0)
413
    //       :......................^..:                   :  ^   :
414
    //       isl0                   :                      :  :   :
415
    //       .......................:.......................  :   :
416
    // (in1) :-> Blur -> (tmp1) ----'--> Sum ----> (scl0) -----   :
417
    //       :....................................................:
418
    //       isl0        :
419
    //                   `------------> Median -> (tmp3) --> Blur -------> (out1)
420
    //
421

422
    cv::gapi::island("isl0", cv::GIn(in[1], tmp[2]), cv::GOut(out[0]));
423
    cv::gapi::island("isl1", cv::GIn(in[0], tmp[1]), cv::GOut(tmp[2]));
424
    auto cc = cv::GComputation(cv::GIn(in[0], in[1]), cv::GOut(out[0], out[1]))
425
        .compile(cv::GMatDesc{CV_8U,1,{640,480}},
426
                cv::GMatDesc{CV_8U,1,{640,480}});
427

428
    const auto &gm = cc.priv().model();
429
    const auto tmp0_nh = cv::gimpl::GModel::dataNodeOf(gm, tmp[0]);
430
    const auto tmp1_nh = cv::gimpl::GModel::dataNodeOf(gm, tmp[1]);
431
    const auto tmp2_nh = cv::gimpl::GModel::dataNodeOf(gm, tmp[2]);
432

433
    EXPECT_EQ("isl1", gm.metadata(tmp0_nh).get<cv::gimpl::Island>().island);
434
    EXPECT_EQ("isl0", gm.metadata(tmp1_nh).get<cv::gimpl::Island>().island);
435
    EXPECT_FALSE(gm.metadata(tmp2_nh).contains<cv::gimpl::Island>());
436
}
437

438
TEST_F(ComplexIslands, NoWayBetweenNodes)
439
{
440
    // (in0) -> Not  -> (tmp0) --> Add ---------> (tmp2) --> AddC -------> (out0)
441
    //                             ^                         ^
442
    // (in1) -> Blur -> (tmp1) ----'--> Sum ----> (scl0) ----'
443
    //                   :
444
    //                   `------------> Median -> (tmp3) --> Blur -------> (out1)
445

446
    EXPECT_ANY_THROW(cv::gapi::island("isl0", cv::GIn(in[1]), cv::GOut(tmp[0])));
447
}
448

449
TEST_F(ComplexIslands, IslandsContainUnusedPart)
450
{
451
    // Unused part of the graph
452
    // 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
453
    // x                                                                               x
454
    // x(in0) -> Not  -> (tmp0) --> Add ---------> (tmp2)---> AddC ---------> (out0)   x
455
    // x                             ^                         ^                       x
456
    // x x x x x x x x x x x x x x x | x x                     |                       x
457
    //                               |   x                     |                       x
458
    //          ......               |   x                     |                       x
459
    // (in1) -> :Blur:----------> (tmp1) x-----> Sum ------> (scl0)                    x
460
    //          ......    :              x x x x x x x x x x x x x x x x x x x x x x x x
461
    //          isl0
462
    //                    :
463
    //                    `------------> Median -> (tmp3) --> Blur -------> (out1)
464

465
    cv::gapi::island("isl0", cv::GIn(in[1]), cv::GOut(scl));
466
    auto cc = cv::GComputation(cv::GIn(in[1]), cv::GOut(out[1]))
467
        .compile(cv::GMatDesc{CV_8U,1,{640,480}});
468

469
    const auto &gm = cc.priv().model();
470
    const auto tmp1_nh = cv::gimpl::GModel::dataNodeOf(gm, tmp[1]);
471

472
    //The output 0 is not specified in the graph
473
    //means that there will not be a node scl, so that  tmp1 will not assign to the island
474
    // FIXME Check that blur assigned to island using the function producerOf
475
    // After merge islands fusion
476
    EXPECT_FALSE(gm.metadata(tmp1_nh) .contains<cv::gimpl::Island>());
477
}
478

479
TEST_F(ComplexIslands, FullGraphInTwoIslands)
480
{
481
    //       isl0
482
    //          ..................................................
483
    // (in0) -> :Not -> (tmp0) --> Add ---------> (tmp2) --> AddC: -------> (out0)
484
    //          ...................^....                     ^   :
485
    //          ...............    |   :                     :   :
486
    // (in1) -> :Blur-> (tmp1):----'-->:Sum ----> (scl0) ----'   :
487
    //          ........ |    :        ...........................
488
    //          isl1   : |    :............................................
489
    //                 : `------------> Median -> (tmp3) --> Blur ------->:(out1)
490
    //                 ....................................................
491

492
    cv::gapi::island("isl0", cv::GIn(in[0], tmp[1]), cv::GOut(out[0]));
493
    cv::gapi::island("isl1", cv::GIn(in[1]), cv::GOut(out[1]));
494
    auto cc = cv::GComputation(cv::GIn(in[0], in[1]), cv::GOut(out[0], out[1]))
495
        .compile(cv::GMatDesc{CV_8U,1,{640,480}},
496
                cv::GMatDesc{CV_8U,1,{640,480}});
497

498
    const auto &gm = cc.priv().model();
499
    const auto in0_nh  = cv::gimpl::GModel::dataNodeOf(gm, in[0]);
500
    const auto in1_nh  = cv::gimpl::GModel::dataNodeOf(gm, in[1]);
501
    const auto tmp0_nh = cv::gimpl::GModel::dataNodeOf(gm, tmp[0]);
502
    const auto tmp1_nh = cv::gimpl::GModel::dataNodeOf(gm, tmp[1]);
503
    const auto tmp2_nh = cv::gimpl::GModel::dataNodeOf(gm, tmp[2]);
504
    const auto tmp3_nh = cv::gimpl::GModel::dataNodeOf(gm, tmp[3]);
505
    const auto scl_nh  = cv::gimpl::GModel::dataNodeOf(gm, scl);
506
    const auto out0_nh = cv::gimpl::GModel::dataNodeOf(gm, out[0]);
507
    const auto out1_nh = cv::gimpl::GModel::dataNodeOf(gm, out[1]);
508

509
    // Check handles inside isl0
510
    EXPECT_EQ("isl0", gm.metadata(tmp0_nh).get<cv::gimpl::Island>().island);
511
    EXPECT_EQ("isl0", gm.metadata(tmp2_nh).get<cv::gimpl::Island>().island);
512
    EXPECT_EQ("isl0", gm.metadata(scl_nh).get<cv::gimpl::Island>().island);
513

514
    // Check handles inside isl1
515
    EXPECT_EQ("isl1", gm.metadata(tmp1_nh).get<cv::gimpl::Island>().island);
516
    EXPECT_EQ("isl1", gm.metadata(tmp3_nh).get<cv::gimpl::Island>().island);
517

518
    // Check outside handles
519
    EXPECT_FALSE(gm.metadata(in0_nh) .contains<cv::gimpl::Island>());
520
    EXPECT_FALSE(gm.metadata(in1_nh) .contains<cv::gimpl::Island>());
521
    EXPECT_FALSE(gm.metadata(out0_nh).contains<cv::gimpl::Island>());
522
    EXPECT_FALSE(gm.metadata(out1_nh).contains<cv::gimpl::Island>());
523
}
524

525
TEST_F(ComplexIslands, OnlyOperationsAssignedToIslands)
526
{
527
    cv::gapi::island("isl0", cv::GIn(in[1]), cv::GOut(tmp[1]));
528
    cv::gapi::island("isl1", cv::GIn(tmp[1]), cv::GOut(scl));
529
    cv::gapi::island("isl2", cv::GIn(scl, tmp[2]), cv::GOut(out[0]));
530
    cv::gapi::island("isl3", cv::GIn(in[0]), cv::GOut(tmp[0]));
531
    cv::gapi::island("isl4", cv::GIn(tmp[0], tmp[1]), cv::GOut(tmp[2]));
532
    cv::gapi::island("isl5", cv::GIn(tmp[1]), cv::GOut(tmp[3]));
533
    cv::gapi::island("isl6", cv::GIn(tmp[3]), cv::GOut(out[1]));
534

535
    auto cc = cv::GComputation(cv::GIn(in[0], in[1]), cv::GOut(out[0], out[1]))
536
        .compile(cv::GMatDesc{CV_8U,1,{640,480}},
537
                cv::GMatDesc{CV_8U,1,{640,480}});
538

539
    const auto &gm = cc.priv().model();
540
    //FIXME: Check that operation handles are really assigned to isl0..isl6
541
    const auto in0_nh  = cv::gimpl::GModel::dataNodeOf(gm, in[0]);
542
    const auto in1_nh  = cv::gimpl::GModel::dataNodeOf(gm, in[1]);
543
    const auto tmp0_nh = cv::gimpl::GModel::dataNodeOf(gm, tmp[0]);
544
    const auto tmp1_nh = cv::gimpl::GModel::dataNodeOf(gm, tmp[1]);
545
    const auto tmp2_nh = cv::gimpl::GModel::dataNodeOf(gm, tmp[2]);
546
    const auto tmp3_nh = cv::gimpl::GModel::dataNodeOf(gm, tmp[3]);
547
    const auto scl_nh  = cv::gimpl::GModel::dataNodeOf(gm, scl);
548
    const auto out0_nh = cv::gimpl::GModel::dataNodeOf(gm, out[0]);
549
    const auto out1_nh = cv::gimpl::GModel::dataNodeOf(gm, out[1]);
550

551
    EXPECT_FALSE(gm.metadata(in0_nh) .contains<cv::gimpl::Island>());
552
    EXPECT_FALSE(gm.metadata(in1_nh) .contains<cv::gimpl::Island>());
553
    EXPECT_FALSE(gm.metadata(tmp0_nh) .contains<cv::gimpl::Island>());
554
    EXPECT_FALSE(gm.metadata(tmp1_nh) .contains<cv::gimpl::Island>());
555
    EXPECT_FALSE(gm.metadata(tmp2_nh) .contains<cv::gimpl::Island>());
556
    EXPECT_FALSE(gm.metadata(tmp3_nh) .contains<cv::gimpl::Island>());
557
    EXPECT_FALSE(gm.metadata(scl_nh) .contains<cv::gimpl::Island>());
558
    EXPECT_FALSE(gm.metadata(out0_nh).contains<cv::gimpl::Island>());
559
    EXPECT_FALSE(gm.metadata(out1_nh).contains<cv::gimpl::Island>());
560
}
561

562
namespace
563
{
564
    struct IslandStructureWithGArray
565
    {
566
        GIntArray in, out;
567
        GMat tmp;
568

569
        IslandStructureWithGArray()
570
        {
571
            tmp = CreateMatWithDiag::on(in);
572
            out = Mat2Array::on(tmp);
573
        }
574
    };
575

576
    struct IslandsWithGArray: public ::testing::Test, public IslandStructureWithGArray {};
577
} // namespace
578

579
TEST_F(IslandsWithGArray, IslandWithGArrayAsInput)
580
{
581
    cv::gapi::island("isl0", cv::GIn(in), cv::GOut(tmp));
582

583
    const auto pkg = cv::gapi::kernels<CreateMatWithDiagImpl, Mat2ArrayImpl>();
584
    auto cc = cv::GComputation(cv::GIn(in), GOut(out)).compile(cv::empty_array_desc(), cv::compile_args(pkg));
585
    const auto &gm = cc.priv().model();
586

587
    const auto in_nh   = cv::gimpl::GModel::dataNodeOf(gm, in.strip());
588
    const auto out_nh  = cv::gimpl::GModel::dataNodeOf(gm, out.strip());
589
    const auto tmp_nh  = cv::gimpl::GModel::dataNodeOf(gm, tmp);
590
    GAPI_Assert(tmp_nh->inNodes().size() == 1);
591
    const auto create_diag_mat_nh = tmp_nh->inNodes().front();
592

593
    EXPECT_EQ("isl0", gm.metadata(create_diag_mat_nh).get<cv::gimpl::Island>().island);
594
    EXPECT_FALSE(gm.metadata(in_nh) .contains<cv::gimpl::Island>());
595
    EXPECT_FALSE(gm.metadata(out_nh) .contains<cv::gimpl::Island>());
596
    EXPECT_FALSE(gm.metadata(tmp_nh) .contains<cv::gimpl::Island>());
597
}
598

599
TEST_F(IslandsWithGArray, IslandWithGArrayAsOutput)
600
{
601
    cv::gapi::island("isl0", cv::GIn(tmp), cv::GOut(out));
602

603
    const auto pkg = cv::gapi::kernels<CreateMatWithDiagImpl, Mat2ArrayImpl>();
604
    auto cc = cv::GComputation(cv::GIn(in), GOut(out)).compile(cv::empty_array_desc(), cv::compile_args(pkg));
605
    const auto &gm = cc.priv().model();
606

607
    const auto in_nh   = cv::gimpl::GModel::dataNodeOf(gm, in.strip());
608
    const auto out_nh  = cv::gimpl::GModel::dataNodeOf(gm, out.strip());
609
    const auto tmp_nh  = cv::gimpl::GModel::dataNodeOf(gm, tmp);
610
    GAPI_Assert(tmp_nh->inNodes().size() == 1);
611
    const auto mat2array_nh = out_nh->inNodes().front();
612

613
    EXPECT_EQ("isl0", gm.metadata(mat2array_nh).get<cv::gimpl::Island>().island);
614
    EXPECT_FALSE(gm.metadata(in_nh) .contains<cv::gimpl::Island>());
615
    EXPECT_FALSE(gm.metadata(out_nh) .contains<cv::gimpl::Island>());
616
    EXPECT_FALSE(gm.metadata(tmp_nh) .contains<cv::gimpl::Island>());
617
}
618
////////////////////////////////////////////////////////////////////////////////
619
// Wrong input tests on island name
620
//
621
namespace
622
{
623
    struct CheckName : public TestWithParam<std::tuple<bool, const char*> >,
624
                       public PlainIslandsFixture
625
    {
626
        void assignIsland(const std::string &s)
627
        {
628
            cv::gapi::island(s, cv::GIn(tmp[0]), cv::GOut(tmp[2]));
629
        };
630
    };
631
    TEST_P(CheckName, Test)
632
    {
633
        bool correct = false;
634
        const char *name = "";
635
        std::tie(correct, name) = GetParam();
636
        if (correct) EXPECT_NO_THROW(assignIsland(name));
637
        else EXPECT_ANY_THROW(assignIsland(name));
638
    }
639
} // namespace
640
INSTANTIATE_TEST_CASE_P(IslandName, CheckName,
641
                        Values(std::make_tuple(true,  "name"),
642
                               std::make_tuple(true,  " name "),
643
                               std::make_tuple(true,  " n a m e "),
644
                               std::make_tuple(true,  " 123 $$ %%"),
645
                               std::make_tuple(true,  ".: -"),
646
                               std::make_tuple(false, ""),
647
                               std::make_tuple(false, " "),
648
                               std::make_tuple(false, " \t "),
649
                               std::make_tuple(false, "  \t \t   ")));
650

651
// FIXME: add <internal> test on unrollExpr() use for islands
652

653
} // opencv_test
654

655
Product

Resources

Company
