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 #include <opencv2/gapi/own/mat.hpp>
10 #include <opencv2/gapi/own/convert.hpp>
11 #include <opencv2/gapi/util/compiler_hints.hpp> //suppress_unused_warning
12
13 namespace opencv_test
14 {
15 using Mat = cv::gapi::own::Mat;
16 using Dims = std::vector<int>;
17
18 namespace {
multiply_dims(Dims const & dims)19 inline std::size_t multiply_dims(Dims const& dims){
20 return std::accumulate(dims.begin(), dims.end(), static_cast<size_t>(1), std::multiplies<std::size_t>());
21 }
22 }
23
TEST(OwnMat,DefaultConstruction)24 TEST(OwnMat, DefaultConstruction)
25 {
26 Mat m;
27 ASSERT_EQ(m.data, nullptr);
28 ASSERT_EQ(m.cols, 0);
29 ASSERT_EQ(m.rows, 0);
30 ASSERT_EQ(m.cols, 0);
31 ASSERT_EQ(m.type(), 0);
32 ASSERT_EQ(m.depth(), 0);
33 ASSERT_TRUE(m.dims.empty());
34 ASSERT_TRUE(m.empty());
35 }
36
TEST(OwnMat,Create)37 TEST(OwnMat, Create)
38 {
39 auto size = cv::gapi::own::Size{32,16};
40 Mat m;
41 m.create(size, CV_8UC1);
42
43 ASSERT_NE(m.data, nullptr);
44 ASSERT_EQ((cv::gapi::own::Size{m.cols, m.rows}), size);
45
46 ASSERT_EQ(m.total(), static_cast<size_t>(size.height) * size.width);
47 ASSERT_EQ(m.type(), CV_8UC1);
48 ASSERT_EQ(m.depth(), CV_8U);
49 ASSERT_EQ(m.channels(), 1);
50 ASSERT_EQ(m.elemSize(), sizeof(uint8_t));
51 ASSERT_EQ(m.step, sizeof(uint8_t) * m.cols);
52 ASSERT_TRUE(m.dims.empty());
53 ASSERT_FALSE(m.empty());
54 }
55
TEST(OwnMat,CreateND)56 TEST(OwnMat, CreateND)
57 {
58 Dims dims = {1,1,32,32};
59 Mat m;
60 m.create(dims, CV_32F);
61
62 ASSERT_NE(nullptr , m.data );
63 ASSERT_EQ((cv::gapi::own::Size{0,0}), (cv::gapi::own::Size{m.cols, m.rows}));
64
65 ASSERT_EQ(multiply_dims(dims), m.total());
66 ASSERT_EQ(CV_32F , m.type() );
67 ASSERT_EQ(CV_32F , m.depth() );
68 ASSERT_EQ(-1 , m.channels());
69 ASSERT_EQ(sizeof(float) , m.elemSize());
70 ASSERT_EQ(0u , m.step );
71 ASSERT_EQ(dims , m.dims );
72 ASSERT_FALSE(m.empty());
73 }
74
TEST(OwnMat,CreateOverload)75 TEST(OwnMat, CreateOverload)
76 {
77 auto size = cv::gapi::own::Size{32,16};
78 Mat m;
79 m.create(size.height,size.width, CV_8UC1);
80
81 ASSERT_NE(m.data, nullptr);
82 ASSERT_EQ((cv::Size{m.cols, m.rows}), size);
83
84 ASSERT_EQ(m.total(), static_cast<size_t>(size.height) * size.width);
85 ASSERT_EQ(m.type(), CV_8UC1);
86 ASSERT_EQ(m.depth(), CV_8U);
87 ASSERT_EQ(m.channels(), 1);
88 ASSERT_EQ(m.elemSize(), sizeof(uint8_t));
89 ASSERT_EQ(m.step, sizeof(uint8_t) * m.cols);
90 ASSERT_TRUE(m.dims.empty());
91 ASSERT_FALSE(m.empty());
92 }
93
TEST(OwnMat,Create3chan)94 TEST(OwnMat, Create3chan)
95 {
96 auto size = cv::Size{32,16};
97 Mat m;
98 m.create(size, CV_8UC3);
99
100 ASSERT_NE(m.data, nullptr);
101 ASSERT_EQ((cv::Size{m.cols, m.rows}), size);
102
103 ASSERT_EQ(m.type(), CV_8UC3);
104 ASSERT_EQ(m.depth(), CV_8U);
105 ASSERT_EQ(m.channels(), 3);
106 ASSERT_EQ(m.elemSize(), 3 * sizeof(uint8_t));
107 ASSERT_EQ(m.step, 3* sizeof(uint8_t) * m.cols);
108 ASSERT_TRUE(m.dims.empty());
109 ASSERT_FALSE(m.empty());
110 }
111
112 struct NonEmptyMat {
113 cv::gapi::own::Size size{32,16};
114 Mat m;
NonEmptyMatopencv_test::NonEmptyMat115 NonEmptyMat() {
116 m.create(size, CV_8UC1);
117 }
118 };
119
120 struct OwnMatSharedSemantics : NonEmptyMat, ::testing::Test {};
121
122
123 namespace {
__anon131890920302(Mat const& mat) 124 auto state_of = [](Mat const& mat) {
125 return std::make_tuple(
126 mat.data,
127 cv::Size{mat.cols, mat.rows},
128 mat.type(),
129 mat.depth(),
130 mat.channels(),
131 mat.dims,
132 mat.empty()
133 );
134 };
135
ensure_mats_are_same(Mat const & copy,Mat const & m)136 void ensure_mats_are_same(Mat const& copy, Mat const& m){
137 EXPECT_NE(copy.data, nullptr);
138 EXPECT_EQ(state_of(copy), state_of(m));
139 }
140 }
TEST_F(OwnMatSharedSemantics,CopyConstruction)141 TEST_F(OwnMatSharedSemantics, CopyConstruction)
142 {
143 Mat copy(m);
144 ensure_mats_are_same(copy, m);
145 }
146
TEST_F(OwnMatSharedSemantics,CopyAssignment)147 TEST_F(OwnMatSharedSemantics, CopyAssignment)
148 {
149 Mat copy;
150 copy = m;
151 ensure_mats_are_same(copy, m);
152 }
153
154 struct OwnMatMoveSemantics : NonEmptyMat, ::testing::Test {
155 Mat& moved_from = m;
156 decltype(state_of(moved_from)) initial_state = state_of(moved_from);
157
ensure_state_moved_toopencv_test::OwnMatMoveSemantics158 void ensure_state_moved_to(Mat const& moved_to)
159 {
160 EXPECT_EQ(state_of(moved_to), initial_state);
161 EXPECT_EQ(state_of(moved_from), state_of(Mat{}));
162 }
163 };
164
TEST_F(OwnMatMoveSemantics,MoveConstruction)165 TEST_F(OwnMatMoveSemantics, MoveConstruction)
166 {
167 Mat moved_to(std::move(moved_from));
168
169 ensure_state_moved_to(moved_to);
170 }
171
TEST_F(OwnMatMoveSemantics,MoveAssignment)172 TEST_F(OwnMatMoveSemantics, MoveAssignment)
173 {
174 Mat moved_to(std::move(moved_from));
175 ensure_state_moved_to(moved_to);
176 }
177
178 struct OwnMatNonOwningView : NonEmptyMat, ::testing::Test {
179 decltype(state_of(m)) initial_state = state_of(m);
180
TearDownopencv_test::OwnMatNonOwningView181 void TearDown() override {
182 EXPECT_EQ(state_of(m), initial_state)<<"State of the source matrix changed?";
183 //ASAN should complain here if memory is freed here (e.g. by bug in non owning logic of own::Mat)
184 volatile uchar dummy = m.data[0];
185 cv::util::suppress_unused_warning(dummy);
186 }
187
188 };
189
TEST_F(OwnMatNonOwningView,Construction)190 TEST_F(OwnMatNonOwningView, Construction)
191 {
192 Mat non_owning_view(m.rows, m.cols, m.type(), static_cast<void*>(m.data));
193
194 ensure_mats_are_same(non_owning_view, m);
195 }
196
TEST_F(OwnMatNonOwningView,CopyConstruction)197 TEST_F(OwnMatNonOwningView, CopyConstruction)
198 {
199 Mat non_owning_view{m.rows, m.cols, m.type(), static_cast<void*>(m.data)};
200
201 Mat non_owning_view_copy = non_owning_view;
202 ensure_mats_are_same(non_owning_view_copy, m);
203 }
204
TEST_F(OwnMatNonOwningView,Assignment)205 TEST_F(OwnMatNonOwningView, Assignment)
206 {
207 Mat non_owning_view{m.rows, m.cols, m.type(), static_cast<void*>(m.data)};
208 Mat non_owning_view_copy;
209
210 non_owning_view_copy = non_owning_view;
211 ensure_mats_are_same(non_owning_view_copy, m);
212 }
213
TEST(OwnMatConversion,WithStep)214 TEST(OwnMatConversion, WithStep)
215 {
216 constexpr int width = 8;
217 constexpr int height = 8;
218 constexpr int stepInPixels = 16;
219
220 std::array<int, height * stepInPixels> data;
221 for (size_t i = 0; i < data.size(); i++)
222 {
223 data[i] = static_cast<int>(i);
224 }
225 cv::Mat cvMat(cv::Size{width, height}, CV_32S, data.data(), stepInPixels * sizeof(int));
226
227 auto ownMat = to_own(cvMat);
228 auto cvMatFromOwn = cv::gapi::own::to_ocv(ownMat);
229
230 EXPECT_EQ(0, cvtest::norm(cvMat, cvMatFromOwn, NORM_INF))
231 << cvMat << std::endl
232 << (cvMat != cvMatFromOwn);
233 }
234
TEST(OwnMatConversion,WithND)235 TEST(OwnMatConversion, WithND)
236 {
237 const Dims dims = {1,3,8,8};
238 std::vector<uint8_t> data(dims[0]*dims[1]*dims[2]*dims[3]);
239 for (size_t i = 0u; i < data.size(); i++)
240 {
241 data[i] = static_cast<uint8_t>(i);
242 }
243 cv::Mat cvMat(dims, CV_8U, data.data());
244 auto ownMat = to_own(cvMat);
245 auto cvMatFromOwn = cv::gapi::own::to_ocv(ownMat);
246
247 EXPECT_EQ(0, cv::norm(cvMat, cvMatFromOwn, NORM_INF))
248 << cvMat << std::endl
249 << (cvMat != cvMatFromOwn);
250 }
251
TEST(OwnMat,PtrWithStep)252 TEST(OwnMat, PtrWithStep)
253 {
254 constexpr int width = 8;
255 constexpr int height = 8;
256 constexpr int stepInPixels = 16;
257
258 std::array<int, height * stepInPixels> data;
259 for (size_t i = 0; i < data.size(); i++)
260 {
261 data[i] = static_cast<int>(i);
262 }
263 Mat mat(height, width, CV_32S, data.data(), stepInPixels * sizeof(int));
264
265 EXPECT_EQ(& data[0], reinterpret_cast<int*>(mat.ptr(0)));
266 EXPECT_EQ(& data[1], reinterpret_cast<int*>(mat.ptr(0, 1)));
267 EXPECT_EQ(& data[stepInPixels], reinterpret_cast<int*>(mat.ptr(1)));
268 EXPECT_EQ(& data[stepInPixels +1], reinterpret_cast<int*>(mat.ptr(1,1)));
269
270 auto const& cmat = mat;
271
272 EXPECT_EQ(& data[0], reinterpret_cast<const int*>(cmat.ptr(0)));
273 EXPECT_EQ(& data[1], reinterpret_cast<const int*>(cmat.ptr(0, 1)));
274 EXPECT_EQ(& data[stepInPixels], reinterpret_cast<const int*>(cmat.ptr(1)));
275 EXPECT_EQ(& data[stepInPixels +1], reinterpret_cast<const int*>(cmat.ptr(1,1)));
276 }
277
TEST(OwnMat,CopyToWithStep)278 TEST(OwnMat, CopyToWithStep)
279 {
280 constexpr int width = 8;
281 constexpr int height = 8;
282 constexpr int stepInPixels = 16;
283
284 std::array<int, height * stepInPixels> data;
285 for (size_t i = 0; i < data.size(); i++)
286 {
287 data[i] = static_cast<int>(i);
288 }
289 Mat mat(height, width, CV_32S, data.data(), stepInPixels * sizeof(int));
290
291 Mat dst;
292 mat.copyTo(dst);
293
294 EXPECT_NE(mat.data, dst.data);
295 EXPECT_EQ(0, cvtest::norm(to_ocv(mat), to_ocv(dst), NORM_INF))
296 << to_ocv(mat) << std::endl
297 << (to_ocv(mat) != to_ocv(dst));
298 }
299
TEST(OwnMat,AssignNDtoRegular)300 TEST(OwnMat, AssignNDtoRegular)
301 {
302 const auto sz = cv::gapi::own::Size{32,32};
303 const auto dims = Dims{1,3,224,224};
304
305 Mat a;
306 a.create(sz, CV_8U);
307 const auto *old_ptr = a.data;
308
309 ASSERT_NE(nullptr , a.data);
310 ASSERT_EQ(sz , (cv::gapi::own::Size{a.cols, a.rows}));
311 ASSERT_EQ(static_cast<size_t>(sz.width) * sz.height, a.total());
312 ASSERT_EQ(CV_8U , a.type());
313 ASSERT_EQ(CV_8U , a.depth());
314 ASSERT_EQ(1 , a.channels());
315 ASSERT_EQ(sizeof(uint8_t), a.elemSize());
316 ASSERT_EQ(static_cast<size_t>(sz.width), a.step);
317 ASSERT_TRUE(a.dims.empty());
318
319 Mat b;
320 b.create(dims, CV_32F);
321 a = b;
322
323 ASSERT_NE(nullptr , a.data);
324 ASSERT_NE(old_ptr , a.data);
325 ASSERT_EQ((cv::gapi::own::Size{0,0}), (cv::gapi::own::Size{a.cols, a.rows}));
326 ASSERT_EQ(multiply_dims(dims), a.total());
327 ASSERT_EQ(CV_32F , a.type());
328 ASSERT_EQ(CV_32F , a.depth());
329 ASSERT_EQ(-1 , a.channels());
330 ASSERT_EQ(sizeof(float), a.elemSize());
331 ASSERT_EQ(0u , a.step);
332 ASSERT_EQ(dims , a.dims);
333 }
334
TEST(OwnMat,AssignRegularToND)335 TEST(OwnMat, AssignRegularToND)
336 {
337 const auto sz = cv::gapi::own::Size{32,32};
338 const auto dims = Dims{1,3,224,224};
339
340 Mat a;
341 a.create(dims, CV_32F);
342 const auto *old_ptr = a.data;
343
344 ASSERT_NE(nullptr , a.data);
345 ASSERT_EQ((cv::gapi::own::Size{0,0}), (cv::gapi::own::Size{a.cols, a.rows}));
346 ASSERT_EQ(multiply_dims(dims), a.total());
347 ASSERT_EQ(CV_32F , a.type());
348 ASSERT_EQ(CV_32F , a.depth());
349 ASSERT_EQ(-1 , a.channels());
350 ASSERT_EQ(sizeof(float), a.elemSize());
351 ASSERT_EQ(0u , a.step);
352 ASSERT_EQ(dims , a.dims);
353
354 Mat b;
355 b.create(sz, CV_8U);
356 a = b;
357
358 ASSERT_NE(nullptr , a.data);
359 ASSERT_NE(old_ptr , a.data);
360 ASSERT_EQ(sz , (cv::gapi::own::Size{a.cols, a.rows}));
361 ASSERT_EQ(static_cast<size_t>(sz.width) * sz.height, a.total());
362 ASSERT_EQ(CV_8U , a.type());
363 ASSERT_EQ(CV_8U , a.depth());
364 ASSERT_EQ(1 , a.channels());
365 ASSERT_EQ(sizeof(uint8_t), a.elemSize());
366 ASSERT_EQ(static_cast<size_t>(sz.width), a.step);
367 ASSERT_TRUE(a.dims.empty());
368 }
369
TEST(OwnMat,CopyNDtoRegular)370 TEST(OwnMat, CopyNDtoRegular)
371 {
372 const auto sz = cv::gapi::own::Size{32,32};
373 const auto dims = Dims{1,3,224,224};
374
375 Mat a;
376 a.create(sz, CV_8U);
377 const auto *old_ptr = a.data;
378
379 ASSERT_NE(nullptr , a.data);
380 ASSERT_EQ(sz , (cv::gapi::own::Size{a.cols, a.rows}));
381 ASSERT_EQ(static_cast<size_t>(sz.width) * sz.height, a.total());
382 ASSERT_EQ(CV_8U , a.type());
383 ASSERT_EQ(CV_8U , a.depth());
384 ASSERT_EQ(1 , a.channels());
385 ASSERT_EQ(sizeof(uint8_t), a.elemSize());
386 ASSERT_EQ(static_cast<size_t>(sz.width), a.step);
387 ASSERT_TRUE(a.dims.empty());
388
389 Mat b;
390 b.create(dims, CV_32F);
391 b.copyTo(a);
392
393 ASSERT_NE(nullptr , a.data);
394 ASSERT_NE(old_ptr , a.data);
395 ASSERT_NE(b.data , a.data);
396 ASSERT_EQ((cv::gapi::own::Size{0,0}), (cv::gapi::own::Size{a.cols, a.rows}));
397 ASSERT_EQ(multiply_dims(dims), a.total());
398 ASSERT_EQ(CV_32F , a.type());
399 ASSERT_EQ(CV_32F , a.depth());
400 ASSERT_EQ(-1 , a.channels());
401 ASSERT_EQ(sizeof(float), a.elemSize());
402 ASSERT_EQ(0u , a.step);
403 ASSERT_EQ(dims , a.dims);
404 }
405
TEST(OwnMat,CopyRegularToND)406 TEST(OwnMat, CopyRegularToND)
407 {
408 const auto sz = cv::gapi::own::Size{32,32};
409 const auto dims = Dims{1,3,224,224};
410
411 Mat a;
412 a.create(dims, CV_32F);
413 const auto *old_ptr = a.data;
414
415
416 ASSERT_NE(nullptr , a.data);
417 ASSERT_EQ((cv::gapi::own::Size{0,0}), (cv::gapi::own::Size{a.cols, a.rows}));
418 ASSERT_EQ(multiply_dims(dims), a.total());
419 ASSERT_EQ(CV_32F , a.type());
420 ASSERT_EQ(CV_32F , a.depth());
421 ASSERT_EQ(-1 , a.channels());
422 ASSERT_EQ(sizeof(float), a.elemSize());
423 ASSERT_EQ(0u , a.step);
424 ASSERT_EQ(dims , a.dims);
425
426 Mat b;
427 b.create(sz, CV_8U);
428 b.copyTo(a);
429
430 ASSERT_NE(nullptr , a.data);
431 ASSERT_NE(old_ptr , a.data);
432 ASSERT_NE(b.data , a.data);
433 ASSERT_EQ(sz , (cv::gapi::own::Size{a.cols, a.rows}));
434 ASSERT_EQ(static_cast<size_t>(sz.width) * sz.height, a.total());
435 ASSERT_EQ(CV_8U , a.type());
436 ASSERT_EQ(CV_8U , a.depth());
437 ASSERT_EQ(1 , a.channels());
438 ASSERT_EQ(sizeof(uint8_t), a.elemSize());
439 ASSERT_EQ(static_cast<size_t>(sz.width), a.step);
440 ASSERT_TRUE(a.dims.empty());
441 }
442
TEST(OwnMat,ScalarAssign32SC1)443 TEST(OwnMat, ScalarAssign32SC1)
444 {
445 constexpr int width = 8;
446 constexpr int height = 8;
447 constexpr int stepInPixels = 16;
448
449 std::array<int, height * stepInPixels> data;
450 for (size_t i = 0; i < data.size(); i++)
451 {
452 data[i] = static_cast<int>(i);
453 }
454 Mat mat(height, width, CV_32S, data.data(), stepInPixels * sizeof(data[0]));
455
456 mat = cv::gapi::own::Scalar{-1};
457
458 std::array<int, height * stepInPixels> expected;
459
460 for (size_t row = 0; row < height; row++)
461 {
462 for (size_t col = 0; col < stepInPixels; col++)
463 {
464 auto index = row*stepInPixels + col;
465 expected[index] = col < width ? -1 : static_cast<int>(index);
466 }
467 }
468
469 auto cmp_result_mat = (cv::Mat{height, stepInPixels, CV_32S, data.data()} != cv::Mat{height, stepInPixels, CV_32S, expected.data()});
470 EXPECT_EQ(0, cvtest::norm(cmp_result_mat, NORM_INF))
471 << cmp_result_mat;
472 }
473
TEST(OwnMat,ScalarAssign8UC1)474 TEST(OwnMat, ScalarAssign8UC1)
475 {
476 constexpr int width = 8;
477 constexpr int height = 8;
478 constexpr int stepInPixels = 16;
479
480 std::array<uchar, height * stepInPixels> data;
481 for (size_t i = 0; i < data.size(); i++)
482 {
483 data[i] = static_cast<uchar>(i);
484 }
485 Mat mat(height, width, CV_8U, data.data(), stepInPixels * sizeof(data[0]));
486
487 mat = cv::gapi::own::Scalar{-1};
488
489 std::array<uchar, height * stepInPixels> expected;
490
491 for (size_t row = 0; row < height; row++)
492 {
493 for (size_t col = 0; col < stepInPixels; col++)
494 {
495 auto index = row*stepInPixels + col;
496 expected[index] = col < width ? cv::saturate_cast<uchar>(-1) : static_cast<uchar>(index);
497 }
498 }
499
500 auto cmp_result_mat = (cv::Mat{height, stepInPixels, CV_8U, data.data()} != cv::Mat{height, stepInPixels, CV_8U, expected.data()});
501 EXPECT_EQ(0, cvtest::norm(cmp_result_mat, NORM_INF))
502 << cmp_result_mat;
503 }
504
TEST(OwnMat,ScalarAssignND)505 TEST(OwnMat, ScalarAssignND)
506 {
507 std::vector<int> dims = {1,1000};
508 Mat m;
509 m.create(dims, CV_32F);
510 m = cv::gapi::own::Scalar{-1};
511 const float *ptr = reinterpret_cast<float*>(m.data);
512
513 for (auto i = 0u; i < m.total(); i++) {
514 EXPECT_EQ(-1.f, ptr[i]);
515 }
516 }
517
TEST(OwnMat,ScalarAssign8UC3)518 TEST(OwnMat, ScalarAssign8UC3)
519 {
520 constexpr auto cv_type = CV_8SC3;
521 constexpr int channels = 3;
522 constexpr int width = 8;
523 constexpr int height = 8;
524 constexpr int stepInPixels = 16;
525
526 std::array<schar, height * stepInPixels * channels> data;
527 for (size_t i = 0; i < data.size(); i+= channels)
528 {
529 data[i + 0] = static_cast<schar>(10 * i + 0);
530 data[i + 1] = static_cast<schar>(10 * i + 1);
531 data[i + 2] = static_cast<schar>(10 * i + 2);
532 }
533
534 Mat mat(height, width, cv_type, data.data(), channels * stepInPixels * sizeof(data[0]));
535
536 mat = cv::gapi::own::Scalar{-10, -11, -12};
537
538 std::array<schar, data.size()> expected;
539
540 for (size_t row = 0; row < height; row++)
541 {
542 for (size_t col = 0; col < stepInPixels; col++)
543 {
544 int index = static_cast<int>(channels * (row*stepInPixels + col));
545 expected[index + 0] = static_cast<schar>(col < width ? -10 : 10 * index + 0);
546 expected[index + 1] = static_cast<schar>(col < width ? -11 : 10 * index + 1);
547 expected[index + 2] = static_cast<schar>(col < width ? -12 : 10 * index + 2);
548 }
549 }
550
551 auto cmp_result_mat = (cv::Mat{height, stepInPixels, cv_type, data.data()} != cv::Mat{height, stepInPixels, cv_type, expected.data()});
552 EXPECT_EQ(0, cvtest::norm(cmp_result_mat, NORM_INF))
553 << cmp_result_mat << std::endl
554 << "data : " << std::endl
555 << cv::Mat{height, stepInPixels, cv_type, data.data()} << std::endl
556 << "expected : " << std::endl
557 << cv::Mat{height, stepInPixels, cv_type, expected.data()} << std::endl;
558 }
559
TEST(OwnMat,ROIView)560 TEST(OwnMat, ROIView)
561 {
562 constexpr int width = 8;
563 constexpr int height = 8;
564 constexpr int stepInPixels = 16;
565
566 std::array<uchar, height * stepInPixels> data;
567 for (size_t i = 0; i < data.size(); i++)
568 {
569 data[i] = static_cast<uchar>(i);
570 }
571
572
573 // std::cout<<cv::Mat{height, stepInPixels, CV_8U, data.data()}<<std::endl;
574
575 std::array<uchar, 4 * 4> expected;
576
577 for (size_t row = 0; row < 4; row++)
578 {
579 for (size_t col = 0; col < 4; col++)
580 {
581 expected[row*4 +col] = static_cast<uchar>(stepInPixels * (2 + row) + 2 + col);
582 }
583 }
584
585 Mat mat(height, width, CV_8U, data.data(), stepInPixels * sizeof(data[0]));
586 Mat roi_view (mat, cv::gapi::own::Rect{2,2,4,4});
587
588 // std::cout<<cv::Mat{4, 4, CV_8U, expected.data()}<<std::endl;
589 //
590 auto expected_cv_mat = cv::Mat{4, 4, CV_8U, expected.data()};
591
592 auto cmp_result_mat = (to_ocv(roi_view) != expected_cv_mat);
593 EXPECT_EQ(0, cvtest::norm(cmp_result_mat, NORM_INF))
594 << cmp_result_mat << std::endl
595 << to_ocv(roi_view) << std::endl
596 << expected_cv_mat << std::endl;
597 }
598
TEST(OwnMat,CreateWithNegativeDims)599 TEST(OwnMat, CreateWithNegativeDims)
600 {
601 Mat own_mat;
602 ASSERT_ANY_THROW(own_mat.create(cv::Size{-1, -1}, CV_8U));
603 }
604
TEST(OwnMat,CreateWithNegativeWidth)605 TEST(OwnMat, CreateWithNegativeWidth)
606 {
607 Mat own_mat;
608 ASSERT_ANY_THROW(own_mat.create(cv::Size{-1, 1}, CV_8U));
609 }
610
TEST(OwnMat,CreateWithNegativeHeight)611 TEST(OwnMat, CreateWithNegativeHeight)
612 {
613 Mat own_mat;
614 ASSERT_ANY_THROW(own_mat.create(cv::Size{1, -1}, CV_8U));
615 }
616
TEST(OwnMat,ZeroHeightMat)617 TEST(OwnMat, ZeroHeightMat)
618 {
619 cv::GMat in, a, b, c, d;
620 std::tie(a, b, c, d) = cv::gapi::split4(in);
621 cv::GMat out = cv::gapi::merge3(a, b, c);
622 cv::Mat in_mat(cv::Size(8, 0), CV_8UC4);
623 cv::Mat out_mat(cv::Size(8, 8), CV_8UC3);
624 cv::GComputation comp(cv::GIn(in), cv::GOut(out));
625 ASSERT_ANY_THROW(comp.apply(cv::gin(in_mat), cv::gout(out_mat),
626 cv::compile_args(cv::gapi::core::fluid::kernels())));
627 }
628
TEST(OwnMat,ZeroWidthMat)629 TEST(OwnMat, ZeroWidthMat)
630 {
631 cv::GMat in, a, b, c, d;
632 std::tie(a, b, c, d) = cv::gapi::split4(in);
633 cv::GMat out = cv::gapi::merge3(a, b, c);
634 cv::Mat in_mat(cv::Size(0, 8), CV_8UC4);
635 cv::Mat out_mat(cv::Size(8, 8), CV_8UC3);
636 cv::GComputation comp(cv::GIn(in), cv::GOut(out));
637 ASSERT_ANY_THROW(comp.apply(cv::gin(in_mat), cv::gout(out_mat),
638 cv::compile_args(cv::gapi::core::fluid::kernels())));
639 }
640
641 } // namespace opencv_test
642