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 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, Compare_Equal_MatDesc)
  44 {
  45     const auto desc1 = cv::GMatDesc{CV_8U, 1, {64, 64}};
  46     const auto desc2 = cv::GMatDesc{CV_8U, 1, {64, 64}};
  47
  48     EXPECT_TRUE(desc1 == desc2);
  49 }
  50
  51 TEST(GAPI_MetaDesc, Compare_Not_Equal_MatDesc)
  52 {
  53     const auto desc1 = cv::GMatDesc{CV_8U,  1, {64, 64}};
  54     const auto desc2 = cv::GMatDesc{CV_32F, 1, {64, 64}};
  55
  56     EXPECT_TRUE(desc1 != desc2);
  57 }
  58
  59 TEST(GAPI_MetaDesc, Compile_MatchMetaNumber_1)
  60 {
  61     cv::GMat in;
  62     cv::GComputation cc(in, in+in);
  63
  64     const auto desc1 = cv::GMatDesc{CV_8U,1,{64,64}};
  65     const auto desc2 = cv::GMatDesc{CV_32F,1,{128,128}};
  66
  67     EXPECT_NO_THROW(cc.compile(desc1));
  68     EXPECT_NO_THROW(cc.compile(desc2));
  69
  70     // FIXME: custom exception type?
  71     // It is worth checking if compilation fails with different number
  72     // of meta parameters
  73     EXPECT_THROW(cc.compile(desc1, desc1),        std::logic_error);
  74     EXPECT_THROW(cc.compile(desc1, desc2, desc2), std::logic_error);
  75 }
  76
  77 TEST(GAPI_MetaDesc, Compile_MatchMetaNumber_2)
  78 {
  79     cv::GMat a, b;
  80     cv::GComputation cc(cv::GIn(a, b), cv::GOut(a+b));
  81
  82     const auto desc1 = cv::GMatDesc{CV_8U,1,{64,64}};
  83     EXPECT_NO_THROW(cc.compile(desc1, desc1));
  84
  85     const auto desc2 = cv::GMatDesc{CV_32F,1,{128,128}};
  86     EXPECT_NO_THROW(cc.compile(desc2, desc2));
  87
  88     // FIXME: custom exception type?
  89     EXPECT_THROW(cc.compile(desc1),               std::logic_error);
  90     EXPECT_THROW(cc.compile(desc2),               std::logic_error);
  91     EXPECT_THROW(cc.compile(desc2, desc2, desc2), std::logic_error);
  92 }
  93
  94 TEST(GAPI_MetaDesc, Compile_MatchMetaType_Mat)
  95 {
  96     cv::GMat in;
  97     cv::GComputation cc(in, in+in);
  98
  99     EXPECT_NO_THROW(cc.compile(cv::GMatDesc{CV_8U,1,{64,64}}));
 100
 101     // FIXME: custom exception type?
 102     EXPECT_THROW(cc.compile(cv::empty_scalar_desc()), std::logic_error);
 103 }
 104
 105 TEST(GAPI_MetaDesc, Compile_MatchMetaType_Scalar)
 106 {
 107     cv::GScalar in;
 108     cv::GComputation cc(cv::GIn(in), cv::GOut(KTest::on(in)));
 109
 110     const auto desc1 = cv::descr_of(cv::Scalar(128));
 111     const auto desc2 = cv::GMatDesc{CV_8U,1,{64,64}};
 112     const auto pkg   = cv::gapi::kernels<GOCVScalarTest>();
 113     EXPECT_NO_THROW(cc.compile(desc1, cv::compile_args(pkg)));
 114
 115     // FIXME: custom exception type?
 116     EXPECT_THROW(cc.compile(desc2, cv::compile_args(pkg)), std::logic_error);
 117 }
 118
 119 TEST(GAPI_MetaDesc, Compile_MatchMetaType_Mixed)
 120 {
 121     cv::GMat a;
 122     cv::GScalar v;
 123     cv::GComputation cc(cv::GIn(a, v), cv::GOut(cv::gapi::addC(a, v)));
 124
 125     const auto desc1 = cv::GMatDesc{CV_8U,1,{64,64}};
 126     const auto desc2 = cv::descr_of(cv::Scalar(4));
 127
 128     EXPECT_NO_THROW(cc.compile(desc1, desc2));
 129
 130     // FIXME: custom exception type(s)?
 131     EXPECT_THROW(cc.compile(desc1),               std::logic_error);
 132     EXPECT_THROW(cc.compile(desc2),               std::logic_error);
 133     EXPECT_THROW(cc.compile(desc2, desc1),        std::logic_error);
 134     EXPECT_THROW(cc.compile(desc1, desc1, desc1), std::logic_error);
 135     EXPECT_THROW(cc.compile(desc1, desc2, desc1), std::logic_error);
 136 }
 137
 138 TEST(GAPI_MetaDesc, Typed_Compile_MatchMetaNumber_1)
 139 {
 140     cv::GComputationT<cv::GMat(cv::GMat)> cc([](cv::GMat in)
 141     {
 142         return in+in;
 143     });
 144
 145     const auto desc1 = cv::GMatDesc{CV_8U,1,{64,64}};
 146     const auto desc2 = cv::GMatDesc{CV_32F,1,{128,128}};
 147
 148     EXPECT_NO_THROW(cc.compile(desc1));
 149     EXPECT_NO_THROW(cc.compile(desc2));
 150 }
 151
 152 TEST(GAPI_MetaDesc, Typed_Compile_MatchMetaNumber_2)
 153 {
 154     cv::GComputationT<cv::GMat(cv::GMat,cv::GMat)> cc([](cv::GMat a, cv::GMat b)
 155     {
 156         return a + b;
 157     });
 158
 159     const auto desc1 = cv::GMatDesc{CV_8U,1,{64,64}};
 160     EXPECT_NO_THROW(cc.compile(desc1, desc1));
 161
 162     const auto desc2 = cv::GMatDesc{CV_32F,1,{128,128}};
 163     EXPECT_NO_THROW(cc.compile(desc2, desc2));
 164 }
 165
 166 TEST(GAPI_MetaDesc, Typed_Compile_MatchMetaType_Mat)
 167 {
 168     cv::GComputationT<cv::GMat(cv::GMat)> cc([](cv::GMat in)
 169     {
 170         return in+in;
 171     });
 172
 173     EXPECT_NO_THROW(cc.compile(cv::GMatDesc{CV_8U,1,{64,64}}));
 174 }
 175
 176 TEST(GAPI_MetaDesc, Typed_Compile_MatchMetaType_Scalar)
 177 {
 178     cv::GComputationT<cv::GScalar(cv::GScalar)> cc([](cv::GScalar in)
 179     {
 180         return KTest::on(in);
 181     });
 182
 183     const auto desc1 = cv::descr_of(cv::Scalar(128));
 184     const auto pkg = cv::gapi::kernels<GOCVScalarTest>();
 185     //     EXPECT_NO_THROW(cc.compile(desc1, cv::compile_args(pkg)));
 186     cc.compile(desc1, cv::compile_args(pkg));
 187 }
 188
 189 TEST(GAPI_MetaDesc, Typed_Compile_MatchMetaType_Mixed)
 190 {
 191     cv::GComputationT<cv::GMat(cv::GMat,cv::GScalar)> cc([](cv::GMat a, cv::GScalar v)
 192     {
 193         return cv::gapi::addC(a, v);
 194     });
 195
 196     const auto desc1 = cv::GMatDesc{CV_8U,1,{64,64}};
 197     const auto desc2 = cv::descr_of(cv::Scalar(4));
 198
 199     EXPECT_NO_THROW(cc.compile(desc1, desc2));
 200 }
 201
 202 } // namespace opencv_test