inference-engine/thirdparty/fluid/modules/gapi/test/gapi_desc_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
  10 #include "opencv2/gapi/cpu/gcpukernel.hpp"
  11
  12 namespace opencv_test
  13 {
  14
  15 namespace
  16 {
  17     G_TYPED_KERNEL(KTest, <cv::GScalar(cv::GScalar)>, "org.opencv.test.scalar_kernel") {
  18         static cv::GScalarDesc outMeta(cv::GScalarDesc in) { return in; }
  19     };
  20     GAPI_OCV_KERNEL(GOCVScalarTest, KTest)
  21     {
  22         static void run(const cv::Scalar &in, cv::Scalar &out) { out = in+cv::Scalar(1); }
  23     };
  24 }
  25
  26 TEST(GAPI_MetaDesc, MatDesc)
  27 {
  28     cv::Mat m1(240, 320, CV_8U);
  29     const auto desc1 = cv::descr_of(m1);
  30     EXPECT_EQ(CV_8U, desc1.depth);
  31     EXPECT_EQ(1,     desc1.chan);
  32     EXPECT_EQ(320,   desc1.size.width);
  33     EXPECT_EQ(240,   desc1.size.height);
  34
  35     cv::Mat m2(480, 640, CV_8UC3);
  36     const auto desc2 = cv::descr_of(m2);
  37     EXPECT_EQ(CV_8U, desc2.depth);
  38     EXPECT_EQ(3,       desc2.chan);
  39     EXPECT_EQ(640,     desc2.size.width);
  40     EXPECT_EQ(480,     desc2.size.height);
  41 }
  42
  43 TEST(GAPI_MetaDesc, VecMatDesc)
  44 {
  45     std::vector<cv::Mat> vec1 = {
  46     cv::Mat(240, 320, CV_8U)};
  47
  48     const auto desc1 = cv::descr_of(vec1);
  49     EXPECT_EQ((GMatDesc{CV_8U, 1, {320, 240}}), get<GMatDesc>(desc1[0]));
  50
  51     std::vector<cv::UMat> vec2 = {
  52     cv::UMat(480, 640, CV_8UC3)};
  53
  54     const auto desc2 = cv::descr_of(vec2);
  55     EXPECT_EQ((GMatDesc{CV_8U, 3, {640, 480}}), get<GMatDesc>(desc2[0]));
  56 }
  57
  58 TEST(GAPI_MetaDesc, VecOwnMatDesc)
  59 {
  60     std::vector<cv::gapi::own::Mat> vec = {
  61     cv::gapi::own::Mat(240, 320, CV_8U, nullptr),
  62     cv::gapi::own::Mat(480, 640, CV_8UC3, nullptr)};
  63
  64     const auto desc = cv::gapi::own::descr_of(vec);
  65     EXPECT_EQ((GMatDesc{CV_8U, 1, {320, 240}}), get<GMatDesc>(desc[0]));
  66     EXPECT_EQ((GMatDesc{CV_8U, 3, {640, 480}}), get<GMatDesc>(desc[1]));
  67 }
  68
  69 TEST(GAPI_MetaDesc, AdlVecOwnMatDesc)
  70 {
  71     std::vector<cv::gapi::own::Mat> vec = {
  72     cv::gapi::own::Mat(240, 320, CV_8U, nullptr),
  73     cv::gapi::own::Mat(480, 640, CV_8UC3, nullptr)};
  74
  75     const auto desc = descr_of(vec);
  76     EXPECT_EQ((GMatDesc{CV_8U, 1, {320, 240}}), get<GMatDesc>(desc[0]));
  77     EXPECT_EQ((GMatDesc{CV_8U, 3, {640, 480}}), get<GMatDesc>(desc[1]));
  78 }
  79
  80 TEST(GAPI_MetaDesc, Compare_Equal_MatDesc)
  81 {
  82     const auto desc1 = cv::GMatDesc{CV_8U, 1, {64, 64}};
  83     const auto desc2 = cv::GMatDesc{CV_8U, 1, {64, 64}};
  84
  85     EXPECT_TRUE(desc1 == desc2);
  86 }
  87
  88 TEST(GAPI_MetaDesc, Compare_Not_Equal_MatDesc)
  89 {
  90     const auto desc1 = cv::GMatDesc{CV_8U,  1, {64, 64}};
  91     const auto desc2 = cv::GMatDesc{CV_32F, 1, {64, 64}};
  92
  93     EXPECT_TRUE(desc1 != desc2);
  94 }
  95
  96 TEST(GAPI_MetaDesc, Compile_MatchMetaNumber_1)
  97 {
  98     cv::GMat in;
  99     cv::GComputation cc(in, in+in);
 100
 101     const auto desc1 = cv::GMatDesc{CV_8U,1,{64,64}};
 102     const auto desc2 = cv::GMatDesc{CV_32F,1,{128,128}};
 103
 104     EXPECT_NO_THROW(cc.compile(desc1));
 105     EXPECT_NO_THROW(cc.compile(desc2));
 106
 107     // FIXME: custom exception type?
 108     // It is worth checking if compilation fails with different number
 109     // of meta parameters
 110     EXPECT_THROW(cc.compile(desc1, desc1),        std::logic_error);
 111     EXPECT_THROW(cc.compile(desc1, desc2, desc2), std::logic_error);
 112 }
 113
 114 TEST(GAPI_MetaDesc, Compile_MatchMetaNumber_2)
 115 {
 116     cv::GMat a, b;
 117     cv::GComputation cc(cv::GIn(a, b), cv::GOut(a+b));
 118
 119     const auto desc1 = cv::GMatDesc{CV_8U,1,{64,64}};
 120     EXPECT_NO_THROW(cc.compile(desc1, desc1));
 121
 122     const auto desc2 = cv::GMatDesc{CV_32F,1,{128,128}};
 123     EXPECT_NO_THROW(cc.compile(desc2, desc2));
 124
 125     // FIXME: custom exception type?
 126     EXPECT_THROW(cc.compile(desc1),               std::logic_error);
 127     EXPECT_THROW(cc.compile(desc2),               std::logic_error);
 128     EXPECT_THROW(cc.compile(desc2, desc2, desc2), std::logic_error);
 129 }
 130
 131 TEST(GAPI_MetaDesc, Compile_MatchMetaType_Mat)
 132 {
 133     cv::GMat in;
 134     cv::GComputation cc(in, in+in);
 135
 136     EXPECT_NO_THROW(cc.compile(cv::GMatDesc{CV_8U,1,{64,64}}));
 137
 138     // FIXME: custom exception type?
 139     EXPECT_THROW(cc.compile(cv::empty_scalar_desc()), std::logic_error);
 140 }
 141
 142 TEST(GAPI_MetaDesc, Compile_MatchMetaType_Scalar)
 143 {
 144     cv::GScalar in;
 145     cv::GComputation cc(cv::GIn(in), cv::GOut(KTest::on(in)));
 146
 147     const auto desc1 = cv::descr_of(cv::Scalar(128));
 148     const auto desc2 = cv::GMatDesc{CV_8U,1,{64,64}};
 149     const auto pkg   = cv::gapi::kernels<GOCVScalarTest>();
 150     EXPECT_NO_THROW(cc.compile(desc1, cv::compile_args(pkg)));
 151
 152     // FIXME: custom exception type?
 153     EXPECT_THROW(cc.compile(desc2, cv::compile_args(pkg)), std::logic_error);
 154 }
 155
 156 TEST(GAPI_MetaDesc, Compile_MatchMetaType_Mixed)
 157 {
 158     cv::GMat a;
 159     cv::GScalar v;
 160     cv::GComputation cc(cv::GIn(a, v), cv::GOut(cv::gapi::addC(a, v)));
 161
 162     const auto desc1 = cv::GMatDesc{CV_8U,1,{64,64}};
 163     const auto desc2 = cv::descr_of(cv::Scalar(4));
 164
 165     EXPECT_NO_THROW(cc.compile(desc1, desc2));
 166
 167     // FIXME: custom exception type(s)?
 168     EXPECT_THROW(cc.compile(desc1),               std::logic_error);
 169     EXPECT_THROW(cc.compile(desc2),               std::logic_error);
 170     EXPECT_THROW(cc.compile(desc2, desc1),        std::logic_error);
 171     EXPECT_THROW(cc.compile(desc1, desc1, desc1), std::logic_error);
 172     EXPECT_THROW(cc.compile(desc1, desc2, desc1), std::logic_error);
 173 }
 174
 175 TEST(GAPI_MetaDesc, Typed_Compile_MatchMetaNumber_1)
 176 {
 177     cv::GComputationT<cv::GMat(cv::GMat)> cc([](cv::GMat in)
 178     {
 179         return in+in;
 180     });
 181
 182     const auto desc1 = cv::GMatDesc{CV_8U,1,{64,64}};
 183     const auto desc2 = cv::GMatDesc{CV_32F,1,{128,128}};
 184
 185     EXPECT_NO_THROW(cc.compile(desc1));
 186     EXPECT_NO_THROW(cc.compile(desc2));
 187 }
 188
 189 TEST(GAPI_MetaDesc, Typed_Compile_MatchMetaNumber_2)
 190 {
 191     cv::GComputationT<cv::GMat(cv::GMat,cv::GMat)> cc([](cv::GMat a, cv::GMat b)
 192     {
 193         return a + b;
 194     });
 195
 196     const auto desc1 = cv::GMatDesc{CV_8U,1,{64,64}};
 197     EXPECT_NO_THROW(cc.compile(desc1, desc1));
 198
 199     const auto desc2 = cv::GMatDesc{CV_32F,1,{128,128}};
 200     EXPECT_NO_THROW(cc.compile(desc2, desc2));
 201 }
 202
 203 TEST(GAPI_MetaDesc, Typed_Compile_MatchMetaType_Mat)
 204 {
 205     cv::GComputationT<cv::GMat(cv::GMat)> cc([](cv::GMat in)
 206     {
 207         return in+in;
 208     });
 209
 210     EXPECT_NO_THROW(cc.compile(cv::GMatDesc{CV_8U,1,{64,64}}));
 211 }
 212
 213 TEST(GAPI_MetaDesc, Typed_Compile_MatchMetaType_Scalar)
 214 {
 215     cv::GComputationT<cv::GScalar(cv::GScalar)> cc([](cv::GScalar in)
 216     {
 217         return KTest::on(in);
 218     });
 219
 220     const auto desc1 = cv::descr_of(cv::Scalar(128));
 221     const auto pkg = cv::gapi::kernels<GOCVScalarTest>();
 222     //     EXPECT_NO_THROW(cc.compile(desc1, cv::compile_args(pkg)));
 223     cc.compile(desc1, cv::compile_args(pkg));
 224 }
 225
 226 TEST(GAPI_MetaDesc, Typed_Compile_MatchMetaType_Mixed)
 227 {
 228     cv::GComputationT<cv::GMat(cv::GMat,cv::GScalar)> cc([](cv::GMat a, cv::GScalar v)
 229     {
 230         return cv::gapi::addC(a, v);
 231     });
 232
 233     const auto desc1 = cv::GMatDesc{CV_8U,1,{64,64}};
 234     const auto desc2 = cv::descr_of(cv::Scalar(4));
 235
 236     EXPECT_NO_THROW(cc.compile(desc1, desc2));
 237 }
 238
 239 } // namespace opencv_test