inference-engine/thirdparty/fluid/modules/gapi/test/own/mat_tests.cpp

   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-2019 Intel Corporation
   6
   7
   8 #include "test_precomp.hpp"
   9 #include "opencv2/gapi/own/mat.hpp"
  10 #include <opencv2/gapi/util/compiler_hints.hpp> //suppress_unused_warning
  11
  12 namespace opencv_test
  13 {
  14 using Mat = cv::gapi::own::Mat;
  15
  16 TEST(OwnMat, DefaultConstruction)
  17 {
  18     Mat m;
  19     ASSERT_EQ(m.data, nullptr);
  20     ASSERT_EQ(m.cols, 0);
  21     ASSERT_EQ(m.rows, 0);
  22     ASSERT_EQ(m.cols, 0);
  23     ASSERT_EQ(m.type(), 0);
  24     ASSERT_EQ(m.depth(), 0);
  25 }
  26
  27 TEST(OwnMat, Create)
  28 {
  29     auto size = cv::gapi::own::Size{32,16};
  30     Mat m;
  31     m.create(size, CV_8UC1);
  32
  33     ASSERT_NE(m.data, nullptr);
  34     ASSERT_EQ((cv::gapi::own::Size{m.cols, m.rows}), size);
  35
  36     ASSERT_EQ(m.total(), static_cast<size_t>(size.height*size.width));
  37     ASSERT_EQ(m.type(), CV_8UC1);
  38     ASSERT_EQ(m.depth(), CV_8U);
  39     ASSERT_EQ(m.channels(), 1);
  40     ASSERT_EQ(m.elemSize(), sizeof(uint8_t));
  41     ASSERT_EQ(m.step,   sizeof(uint8_t) * m.cols);
  42 }
  43
  44 TEST(OwnMat, CreateOverload)
  45 {
  46     auto size = cv::gapi::own::Size{32,16};
  47     Mat m;
  48     m.create(size.height,size.width, CV_8UC1);
  49
  50     ASSERT_NE(m.data, nullptr);
  51     ASSERT_EQ((cv::Size{m.cols, m.rows}), size);
  52
  53     ASSERT_EQ(m.total(), static_cast<size_t>(size.height*size.width));
  54     ASSERT_EQ(m.type(), CV_8UC1);
  55     ASSERT_EQ(m.depth(), CV_8U);
  56     ASSERT_EQ(m.channels(), 1);
  57     ASSERT_EQ(m.elemSize(), sizeof(uint8_t));
  58     ASSERT_EQ(m.step,   sizeof(uint8_t) * m.cols);
  59 }
  60 TEST(OwnMat, Create3chan)
  61 {
  62     auto size = cv::Size{32,16};
  63     Mat m;
  64     m.create(size, CV_8UC3);
  65
  66     ASSERT_NE(m.data, nullptr);
  67     ASSERT_EQ((cv::Size{m.cols, m.rows}), size);
  68
  69     ASSERT_EQ(m.type(), CV_8UC3);
  70     ASSERT_EQ(m.depth(), CV_8U);
  71     ASSERT_EQ(m.channels(), 3);
  72     ASSERT_EQ(m.elemSize(), 3 * sizeof(uint8_t));
  73     ASSERT_EQ(m.step,       3*  sizeof(uint8_t) * m.cols);
  74 }
  75
  76 struct NonEmptyMat {
  77     cv::gapi::own::Size size{32,16};
  78     Mat m;
  79     NonEmptyMat() {
  80         m.create(size, CV_8UC1);
  81     }
  82 };
  83
  84 struct OwnMatSharedSemantics : NonEmptyMat, ::testing::Test {};
  85
  86
  87 namespace {
  88     auto state_of = [](Mat const& mat) {
  89         return std::make_tuple(
  90                 mat.data,
  91                 cv::Size{mat.cols, mat.rows},
  92                 mat.type(),
  93                 mat.depth(),
  94                 mat.channels()
  95         );
  96     };
  97
  98     void ensure_mats_are_same(Mat const& copy, Mat const& m){
  99         EXPECT_NE(copy.data, nullptr);
 100         EXPECT_EQ(state_of(copy), state_of(m));
 101     }
 102 }
 103 TEST_F(OwnMatSharedSemantics, CopyConstruction)
 104 {
 105     Mat copy(m);
 106     ensure_mats_are_same(copy, m);
 107 }
 108
 109 TEST_F(OwnMatSharedSemantics, CopyAssignment)
 110 {
 111     Mat copy;
 112     copy = m;
 113     ensure_mats_are_same(copy, m);
 114 }
 115
 116 struct OwnMatMoveSemantics : NonEmptyMat, ::testing::Test {
 117     Mat& moved_from = m;
 118     decltype(state_of(moved_from)) initial_state = state_of(moved_from);
 119
 120     void ensure_state_moved_to(Mat const& moved_to)
 121     {
 122         EXPECT_EQ(state_of(moved_to),     initial_state);
 123         EXPECT_EQ(state_of(moved_from),   state_of(Mat{}));
 124     }
 125 };
 126
 127 TEST_F(OwnMatMoveSemantics, MoveConstruction)
 128 {
 129     Mat moved_to(std::move(moved_from));
 130
 131     ensure_state_moved_to(moved_to);
 132 }
 133
 134 TEST_F(OwnMatMoveSemantics, MoveAssignment)
 135 {
 136     Mat moved_to(std::move(moved_from));
 137     ensure_state_moved_to(moved_to);
 138 }
 139
 140 struct OwnMatNonOwningView : NonEmptyMat, ::testing::Test {
 141     decltype(state_of(m)) initial_state = state_of(m);
 142
 143     void TearDown() override {
 144         EXPECT_EQ(state_of(m), initial_state)<<"State of the source matrix changed?";
 145         //ASAN should complain here if memory is freed here (e.g. by bug in non owning logic of own::Mat)
 146         volatile uchar dummy =  m.data[0];
 147         cv::util::suppress_unused_warning(dummy);
 148     }
 149
 150 };
 151
 152 TEST_F(OwnMatNonOwningView, Construction)
 153 {
 154     Mat non_owning_view(m.rows, m.cols, m.type(), static_cast<void*>(m.data));
 155
 156     ensure_mats_are_same(non_owning_view, m);
 157 }
 158
 159 TEST_F(OwnMatNonOwningView, CopyConstruction)
 160 {
 161     Mat non_owning_view{m.rows, m.cols, m.type(), static_cast<void*>(m.data)};
 162
 163     Mat non_owning_view_copy = non_owning_view;
 164     ensure_mats_are_same(non_owning_view_copy, m);
 165 }
 166
 167 TEST_F(OwnMatNonOwningView, Assignment)
 168 {
 169     Mat non_owning_view{m.rows, m.cols, m.type(), static_cast<void*>(m.data)};
 170     Mat non_owning_view_copy;
 171
 172     non_owning_view_copy = non_owning_view;
 173     ensure_mats_are_same(non_owning_view_copy, m);
 174 }
 175
 176 TEST(OwnMatConversion, WithStep)
 177 {
 178     constexpr int width  = 8;
 179     constexpr int height = 8;
 180     constexpr int stepInPixels = 16;
 181
 182     std::array<int, height * stepInPixels> data;
 183     for (size_t i = 0; i < data.size(); i++)
 184     {
 185         data[i] = static_cast<int>(i);
 186     }
 187     cv::Mat cvMat(cv::Size{width, height}, CV_32S, data.data(), stepInPixels * sizeof(int));
 188
 189     auto ownMat = to_own(cvMat);
 190     auto cvMatFromOwn = cv::gapi::own::to_ocv(ownMat);
 191
 192     EXPECT_EQ(0, cv::countNonZero(cvMat != cvMatFromOwn))
 193     << cvMat << std::endl
 194     << (cvMat != cvMatFromOwn);
 195 }
 196
 197 TEST(OwnMat, PtrWithStep)
 198 {
 199     constexpr int width  = 8;
 200     constexpr int height = 8;
 201     constexpr int stepInPixels = 16;
 202
 203     std::array<int, height * stepInPixels> data;
 204     for (size_t i = 0; i < data.size(); i++)
 205     {
 206         data[i] = static_cast<int>(i);
 207     }
 208     Mat mat(height, width, CV_32S, data.data(), stepInPixels * sizeof(int));
 209
 210     EXPECT_EQ(& data[0],                reinterpret_cast<int*>(mat.ptr(0)));
 211     EXPECT_EQ(& data[1],                reinterpret_cast<int*>(mat.ptr(0, 1)));
 212     EXPECT_EQ(& data[stepInPixels],     reinterpret_cast<int*>(mat.ptr(1)));
 213     EXPECT_EQ(& data[stepInPixels +1],  reinterpret_cast<int*>(mat.ptr(1,1)));
 214
 215     auto const& cmat = mat;
 216
 217     EXPECT_EQ(& data[0],                reinterpret_cast<const int*>(cmat.ptr(0)));
 218     EXPECT_EQ(& data[1],                reinterpret_cast<const int*>(cmat.ptr(0, 1)));
 219     EXPECT_EQ(& data[stepInPixels],     reinterpret_cast<const int*>(cmat.ptr(1)));
 220     EXPECT_EQ(& data[stepInPixels +1],  reinterpret_cast<const int*>(cmat.ptr(1,1)));
 221 }
 222
 223 TEST(OwnMat, CopyToWithStep)
 224 {
 225     constexpr int width  = 8;
 226     constexpr int height = 8;
 227     constexpr int stepInPixels = 16;
 228
 229     std::array<int, height * stepInPixels> data;
 230     for (size_t i = 0; i < data.size(); i++)
 231     {
 232         data[i] = static_cast<int>(i);
 233     }
 234     Mat mat(height, width, CV_32S, data.data(), stepInPixels * sizeof(int));
 235
 236     Mat dst;
 237     mat.copyTo(dst);
 238
 239     EXPECT_NE(mat.data, dst.data);
 240     EXPECT_EQ(0, cv::countNonZero(to_ocv(mat) != to_ocv(dst)))
 241     << to_ocv(mat) << std::endl
 242     << (to_ocv(mat) != to_ocv(dst));
 243 }
 244
 245 TEST(OwnMat, ScalarAssign32SC1)
 246 {
 247     constexpr int width  = 8;
 248     constexpr int height = 8;
 249     constexpr int stepInPixels = 16;
 250
 251     std::array<int, height * stepInPixels> data;
 252     for (size_t i = 0; i < data.size(); i++)
 253     {
 254         data[i] = static_cast<int>(i);
 255     }
 256     Mat mat(height, width, CV_32S, data.data(), stepInPixels * sizeof(data[0]));
 257
 258     mat = cv::gapi::own::Scalar{-1};
 259
 260     std::array<int, height * stepInPixels> expected;
 261
 262     for (size_t row = 0; row < height; row++)
 263     {
 264         for (size_t col = 0; col < stepInPixels; col++)
 265         {
 266             auto index = row*stepInPixels + col;
 267             expected[index] = col < width ? -1 : static_cast<int>(index);
 268         }
 269     }
 270
 271     auto cmp_result_mat = (cv::Mat{height, stepInPixels, CV_32S, data.data()} != cv::Mat{height, stepInPixels, CV_32S, expected.data()});
 272     EXPECT_EQ(0, cv::countNonZero(cmp_result_mat))
 273     << cmp_result_mat << std::endl;
 274 }
 275
 276 TEST(OwnMat, ScalarAssign8UC1)
 277 {
 278     constexpr int width  = 8;
 279     constexpr int height = 8;
 280     constexpr int stepInPixels = 16;
 281
 282     std::array<uchar, height * stepInPixels> data;
 283     for (size_t i = 0; i < data.size(); i++)
 284     {
 285         data[i] = static_cast<uchar>(i);
 286     }
 287     Mat mat(height, width, CV_8U, data.data(), stepInPixels * sizeof(data[0]));
 288
 289     mat = cv::gapi::own::Scalar{-1};
 290
 291     std::array<uchar, height * stepInPixels> expected;
 292
 293     for (size_t row = 0; row < height; row++)
 294     {
 295         for (size_t col = 0; col < stepInPixels; col++)
 296         {
 297             auto index = row*stepInPixels + col;
 298             expected[index] = col < width ? cv::saturate_cast<uchar>(-1) : static_cast<uchar>(index);
 299         }
 300     }
 301
 302     auto cmp_result_mat = (cv::Mat{height, stepInPixels, CV_8U, data.data()} != cv::Mat{height, stepInPixels, CV_8U, expected.data()});
 303     EXPECT_EQ(0, cv::countNonZero(cmp_result_mat))
 304     << cmp_result_mat << std::endl;
 305 }
 306
 307 TEST(OwnMat, ScalarAssign8UC3)
 308 {
 309     constexpr auto cv_type = CV_8SC3;
 310     constexpr int channels = 3;
 311     constexpr int width  = 8;
 312     constexpr int height = 8;
 313     constexpr int stepInPixels = 16;
 314
 315     std::array<schar, height * stepInPixels * channels> data;
 316     for (size_t i = 0; i < data.size(); i+= channels)
 317     {
 318         data[i + 0] = static_cast<schar>(10 * i + 0);
 319         data[i + 1] = static_cast<schar>(10 * i + 1);
 320         data[i + 2] = static_cast<schar>(10 * i + 2);
 321     }
 322
 323     Mat mat(height, width, cv_type, data.data(), channels * stepInPixels * sizeof(data[0]));
 324
 325     mat = cv::gapi::own::Scalar{-10, -11, -12};
 326
 327     std::array<schar, data.size()> expected;
 328
 329     for (size_t row = 0; row < height; row++)
 330     {
 331         for (size_t col = 0; col < stepInPixels; col++)
 332         {
 333             int index = static_cast<int>(channels * (row*stepInPixels + col));
 334             expected[index + 0] = static_cast<schar>(col < width ? -10 : 10 * index + 0);
 335             expected[index + 1] = static_cast<schar>(col < width ? -11 : 10 * index + 1);
 336             expected[index + 2] = static_cast<schar>(col < width ? -12 : 10 * index + 2);
 337         }
 338     }
 339
 340     auto cmp_result_mat = (cv::Mat{height, stepInPixels, cv_type, data.data()} != cv::Mat{height, stepInPixels, cv_type, expected.data()});
 341     EXPECT_EQ(0, cv::countNonZero(cmp_result_mat))
 342     << cmp_result_mat << std::endl
 343     << "data : " << std::endl
 344     << cv::Mat{height, stepInPixels, cv_type, data.data()}     << std::endl
 345     << "expected : " << std::endl
 346     << cv::Mat{height, stepInPixels, cv_type, expected.data()} << std::endl;
 347 }
 348
 349 TEST(OwnMat, ROIView)
 350 {
 351     constexpr int width  = 8;
 352     constexpr int height = 8;
 353     constexpr int stepInPixels = 16;
 354
 355     std::array<uchar, height * stepInPixels> data;
 356     for (size_t i = 0; i < data.size(); i++)
 357     {
 358         data[i] = static_cast<uchar>(i);
 359     }
 360
 361
 362 //    std::cout<<cv::Mat{height, stepInPixels, CV_8U, data.data()}<<std::endl;
 363
 364     std::array<uchar, 4 * 4> expected;
 365
 366     for (size_t row = 0; row < 4; row++)
 367     {
 368         for (size_t col = 0; col < 4; col++)
 369         {
 370             expected[row*4 +col] = static_cast<uchar>(stepInPixels * (2 + row) + 2 + col);
 371         }
 372     }
 373
 374     Mat mat(height, width, CV_8U, data.data(), stepInPixels * sizeof(data[0]));
 375     Mat roi_view (mat, cv::gapi::own::Rect{2,2,4,4});
 376
 377 //    std::cout<<cv::Mat{4, 4, CV_8U, expected.data()}<<std::endl;
 378 //
 379     auto expected_cv_mat = cv::Mat{4, 4, CV_8U, expected.data()};
 380
 381     auto cmp_result_mat = (to_ocv(roi_view) != expected_cv_mat);
 382     EXPECT_EQ(0, cv::countNonZero(cmp_result_mat))
 383     << cmp_result_mat   << std::endl
 384     << to_ocv(roi_view) << std::endl
 385     << expected_cv_mat  << std::endl;
 386 }
 387 } // namespace opencv_test