mirror/opencv
1
0
Fork 0
mirror of https://github.com/opencv/opencv.git synced 2024-12-03 00:10:21 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity
a110ede0a2
opencv/modules/gapi/test/s11n/gapi_s11n_tests.cpp
AsyaPronina 48ccbe39b4 Changed behaviour of cv::gapi::serialize, cv::gapi::deserialize for GCompileArgs 
- cv::gapi::serialize bypasses compile arguments which have no S11N specialization with serialize/deserialize callbacks for underlying types
- cv::gapi::deserialize can accept arbitraty number of serialized compile args in a stream but will return only those which are requested by user via template parameter pack if they are presented in the stream. If some or all of them are not presented cv::gapi::deserialize will ignore and return only those which are presented
- cv::gapi::deserialize can accept only types which can be deserialized (have S11N<T> specialization with the user callbacks)
- Added cv::gapi::s11n::detail::has_S11N_spec<T> trait to separate compile arguments which have S11N<T> specialization with the user callbacks
2020-11-02 18:55:54 +03:00

825 lines
28 KiB
C++
Raw Blame History

#include "../test_precomp.hpp"
#include "backends/common/serialization.hpp"
#include <opencv2/gapi/rmat.hpp>
namespace {
struct EmptyCustomType { };
struct SimpleCustomType {
bool val;
bool operator==(const SimpleCustomType& other) const {
return val == other.val;
}
};
struct SimpleCustomType2 {
int id;
bool operator==(const SimpleCustomType2& other) const {
return id == other.id;
}
};
struct MyCustomType {
int val;
std::string name;
std::vector<float> vec;
std::map<int, uint64_t> mmap;
bool operator==(const MyCustomType& other) const {
return val == other.val && name == other.name &&
vec == other.vec && mmap == other.mmap;
}
};
struct MyCustomTypeNoS11N {
char sym;
int id;
std::string name;
bool operator==(const MyCustomTypeNoS11N& other) const {
return sym == other.sym && id == other.id &&
name == other.name;
}
};
} // anonymous namespace
namespace cv {
namespace gapi {
namespace s11n {
namespace detail {
template<> struct S11N<EmptyCustomType> {
static void serialize(IOStream &, const EmptyCustomType &) { }
static EmptyCustomType deserialize(IIStream &) { return EmptyCustomType { }; }
};
template<> struct S11N<SimpleCustomType> {
static void serialize(IOStream &os, const SimpleCustomType &p) {
os << p.val;
}
static SimpleCustomType deserialize(IIStream &is) {
SimpleCustomType p;
is >> p.val;
return p;
}
};
template<> struct S11N<SimpleCustomType2> {
static void serialize(IOStream &os, const SimpleCustomType2 &p) {
os << p.id;
}
static SimpleCustomType2 deserialize(IIStream &is) {
SimpleCustomType2 p;
is >> p.id;
return p;
}
};
template<> struct S11N<MyCustomType> {
static void serialize(IOStream &os, const MyCustomType &p) {
os << p.val << p.name << p.vec << p.mmap;
}
static MyCustomType deserialize(IIStream &is) {
MyCustomType p;
is >> p.val >> p.name >> p.vec >> p.mmap;
return p;
}
};
} // namespace detail
} // namespace s11n
} // namespace gapi
} // namespace cv
namespace cv {
namespace detail {
template<> struct CompileArgTag<EmptyCustomType> {
static const char* tag() {
return "org.opencv.test.empty_custom_type";
}
};
template<> struct CompileArgTag<SimpleCustomType> {
static const char* tag() {
return "org.opencv.test.simple_custom_type";
}
};
template<> struct CompileArgTag<SimpleCustomType2> {
static const char* tag() {
return "org.opencv.test.simple_custom_type_2";
}
};
template<> struct CompileArgTag<MyCustomType> {
static const char* tag() {
return "org.opencv.test.my_custom_type";
}
};
template<> struct CompileArgTag<MyCustomTypeNoS11N> {
static const char* tag() {
return "org.opencv.test.my_custom_type_no_s11n";
}
};
} // namespace detail
} // namespace cv
namespace {
class MyRMatAdapter : public cv::RMat::Adapter {
cv::Mat m_mat;
int m_value;
std::string m_str;
public:
MyRMatAdapter() = default;
MyRMatAdapter(cv::Mat m, int value, const std::string& str)
: m_mat(m), m_value(value), m_str(str)
{}
virtual cv::RMat::View access(cv::RMat::Access access) override {
if (access == cv::RMat::Access::W) {
return cv::RMat::View(cv::descr_of(m_mat), m_mat.data, m_mat.step);
} else {
return cv::RMat::View(cv::descr_of(m_mat), m_mat.data, m_mat.step);
}
}
virtual cv::GMatDesc desc() const override { return cv::descr_of(m_mat); }
virtual void serialize(cv::gapi::s11n::IOStream& os) override {
os << m_value << m_str;
}
virtual void deserialize(cv::gapi::s11n::IIStream& is) override {
is >> m_value >> m_str;
}
int getVal() { return m_value; }
std::string getStr() { return m_str; }
};
}
namespace opencv_test {
struct S11N_Basic: public ::testing::Test {
template<typename T> void put(T &&t) {
cv::gapi::s11n::ByteMemoryOutStream os;
os << t;
m_buffer = os.data();
}
template<typename T> T get() {
// FIXME: This stream API needs a fix-up
cv::gapi::s11n::ByteMemoryInStream is(m_buffer);
T t{};
is >> t;
return t;
}
private:
std::vector<char> m_buffer;
};
namespace
{
template<typename T>
bool operator==(const cv::detail::VectorRef& a, const cv::detail::VectorRef& b)
{
return a.rref<T>() == b.rref<T>();
}
template<typename T>
bool operator==(const cv::detail::OpaqueRef& a, const cv::detail::OpaqueRef& b)
{
return a.rref<T>() == b.rref<T>();
}
}
TEST_F(S11N_Basic, Test_int_pos) {
int x = 42;
put(x);
EXPECT_EQ(x, get<int>());
}
TEST_F(S11N_Basic, Test_int_neg) {
int x = -42;
put(x);
EXPECT_EQ(x, get<int>());
}
TEST_F(S11N_Basic, Test_fp32) {
float x = 3.14f;
put(x);
EXPECT_EQ(x, get<float>());
}
TEST_F(S11N_Basic, Test_fp64) {
double x = 3.14;
put(x);
EXPECT_EQ(x, get<double>());
}
TEST_F(S11N_Basic, Test_uint64) {
uint64_t x = 2147483647374;
put(x);
EXPECT_EQ(x, get<uint64_t>());
}
TEST_F(S11N_Basic, Test_int32_pos) {
int32_t x = 2147483647;
put(x);
EXPECT_EQ(x, get<int32_t>());
}
TEST_F(S11N_Basic, Test_int32_neg) {
int32_t x = -2147483646;
put(x);
EXPECT_EQ(x, get<int32_t>());
}
TEST_F(S11N_Basic, Test_vector_bool) {
std::vector<bool> v = {false, true, false};
put(v);
EXPECT_EQ(v, get<std::vector<bool>>());
}
TEST_F(S11N_Basic, Test_map_string2string) {
using T = std::map<std::string, std::string>;
T v;
v["gapi"] = "cool";
v["42"] = "answer";
v["hi"] = "hello there";
put(v);
EXPECT_EQ(v, get<T>());
}
TEST_F(S11N_Basic, Test_map_int2int) {
using T = std::map<int, int32_t>;
T v;
v[1] = 23;
v[-100] = 0;
v[435346] = -12346;
put(v);
EXPECT_EQ(v, get<T>());
}
TEST_F(S11N_Basic, Test_map_float2cvsize) {
using T = std::map<float, cv::Size>;
T v;
v[0.4f] = cv::Size(4, 5);
v[234.43f] = cv::Size(3421, 321);
v[2223.f] = cv::Size(1920, 1080);
put(v);
EXPECT_EQ(v, get<T>());
}
TEST_F(S11N_Basic, Test_map_uint642cvmat) {
using T = std::map<uint64_t, cv::Mat>;
T v;
v[21304805324] = cv::Mat(3, 3, CV_8UC1, cv::Scalar::all(3));
v[4353245222] = cv::Mat(5, 5, CV_8UC3, cv::Scalar::all(7));
v[0] = cv::Mat(10, 10, CV_32FC2, cv::Scalar::all(-128.f));
put(v);
auto out_v = get<T>();
for (const auto& el : out_v) {
EXPECT_NE(v.end(), v.find(el.first));
EXPECT_EQ(0, cv::norm(el.second, v[el.first]));
}
}
TEST_F(S11N_Basic, Test_vector_int) {
std::vector<int> v = {1,2,3};
put(v);
EXPECT_EQ(v, get<std::vector<int>>());
}
TEST_F(S11N_Basic, Test_vector_cvSize) {
std::vector<cv::Size> v = {
cv::Size(640, 480),
cv::Size(1280, 1024),
};
put(v);
EXPECT_EQ(v, get<std::vector<cv::Size>>());
}
TEST_F(S11N_Basic, Test_vector_string) {
std::vector<std::string> v = {
"hello",
"world",
"ok!"
};
put(v);
EXPECT_EQ(v, get<std::vector<std::string>>());
}
TEST_F(S11N_Basic, Test_vector_empty) {
std::vector<char> v;
put(v);
EXPECT_EQ(v, get<std::vector<char>>());
}
TEST_F(S11N_Basic, Test_variant) {
using S = std::string;
using V = cv::util::variant<int,S>;
V v1{42}, v2{S{"hey"}};
put(v1);
EXPECT_EQ(v1, get<V>());
put(v2);
EXPECT_EQ(v2, get<V>());
}
TEST_F(S11N_Basic, Test_GArg_int) {
const int x = 42;
cv::GArg gs(x);
put(gs);
cv::GArg gd = get<cv::GArg>();
EXPECT_EQ(cv::detail::ArgKind::OPAQUE_VAL, gd.kind);
EXPECT_EQ(cv::detail::OpaqueKind::CV_INT, gd.opaque_kind);
EXPECT_EQ(x, gs.get<int>());
}
TEST_F(S11N_Basic, Test_GArg_Point) {
const cv::Point pt{1,2};
cv::GArg gs(pt);
put(gs);
cv::GArg gd = get<cv::GArg>();
EXPECT_EQ(cv::detail::ArgKind::OPAQUE_VAL, gd.kind);
EXPECT_EQ(cv::detail::OpaqueKind::CV_POINT, gd.opaque_kind);
EXPECT_EQ(pt, gs.get<cv::Point>());
}
TEST_F(S11N_Basic, Test_Mat_full) {
auto mat = cv::Mat::eye(cv::Size(64,64), CV_8UC3);
put(mat);
EXPECT_EQ(0, cv::norm(mat, get<cv::Mat>(), cv::NORM_INF));
}
TEST_F(S11N_Basic, Test_Mat_view) {
auto mat = cv::Mat::eye(cv::Size(320,240), CV_8UC3);
auto view = mat(cv::Rect(10,15,123,70));
put(view);
EXPECT_EQ(0, cv::norm(view, get<cv::Mat>(), cv::NORM_INF));
}
TEST_F(S11N_Basic, Test_MatDesc) {
cv::GMatDesc v = { CV_8U, 1, {320,240} };
put(v);
EXPECT_EQ(v, get<cv::GMatDesc>());
}
TEST_F(S11N_Basic, Test_MetaArg_MatDesc) {
cv::GMatDesc desc = { CV_8U, 1,{ 320,240 } };
auto v = cv::GMetaArg{ desc };
put(v);
cv::GMetaArg out_v = get<cv::GMetaArg>();
cv::GMatDesc out_desc = cv::util::get<cv::GMatDesc>(out_v);
EXPECT_EQ(desc, out_desc);
}
TEST_F(S11N_Basic, Test_MetaArgs_MatDesc) {
cv::GMatDesc desc1 = { CV_8U, 1,{ 320,240 } };
cv::GMatDesc desc2 = { CV_8U, 1,{ 640,480 } };
GMetaArgs v;
v.resize(2);
v[0] = cv::GMetaArg{ desc1 };
v[1] = cv::GMetaArg{ desc2 };
put(v);
cv::GMetaArgs out_v = get<cv::GMetaArgs>();
cv::GMatDesc out_desc1 = cv::util::get<cv::GMatDesc>(out_v[0]);
cv::GMatDesc out_desc2 = cv::util::get<cv::GMatDesc>(out_v[1]);
EXPECT_EQ(desc1, out_desc1);
EXPECT_EQ(desc2, out_desc2);
}
TEST_F(S11N_Basic, Test_MetaArg_Monostate) {
GMetaArg v;
put(v);
cv::GMetaArg out_v = get<cv::GMetaArg>();
if (!util::holds_alternative<util::monostate>(out_v))
{
GTEST_FAIL();
}
}
TEST_F(S11N_Basic, Test_RunArg_Mat) {
cv::Mat mat = cv::Mat::eye(cv::Size(64, 64), CV_8UC3);
auto v = cv::GRunArg{ mat };
put(v);
cv::GRunArg out_v = get<cv::GRunArg>();
cv::Mat out_mat = cv::util::get<cv::Mat>(out_v);
EXPECT_EQ(0, cv::norm(mat, out_mat, cv::NORM_INF));
}
TEST_F(S11N_Basic, Test_RunArgs_Mat) {
cv::Mat mat1 = cv::Mat::eye(cv::Size(64, 64), CV_8UC3);
cv::Mat mat2 = cv::Mat::eye(cv::Size(128, 128), CV_8UC3);
GRunArgs v;
v.resize(2);
v[0] = cv::GRunArg{ mat1 };
v[1] = cv::GRunArg{ mat2 };
put(v);
cv::GRunArgs out_v = get<cv::GRunArgs>();
cv::Mat out_mat1 = cv::util::get<cv::Mat>(out_v[0]);
cv::Mat out_mat2 = cv::util::get<cv::Mat>(out_v[1]);
EXPECT_EQ(0, cv::norm(mat1, out_mat1, cv::NORM_INF));
EXPECT_EQ(0, cv::norm(mat2, out_mat2, cv::NORM_INF));
}
TEST_F(S11N_Basic, Test_RunArg_Scalar) {
cv::Scalar scalar = cv::Scalar(128, 33, 53);
auto v = cv::GRunArg{ scalar };
put(v);
cv::GRunArg out_v = get<cv::GRunArg>();
cv::Scalar out_scalar = cv::util::get<cv::Scalar>(out_v);
EXPECT_EQ(scalar, out_scalar);
}
TEST_F(S11N_Basic, Test_RunArgs_Scalar) {
cv::Scalar scalar1 = cv::Scalar(128, 33, 53);
cv::Scalar scalar2 = cv::Scalar(64, 15, 23);
GRunArgs v;
v.resize(2);
v[0] = cv::GRunArg{ scalar1 };
v[1] = cv::GRunArg{ scalar2 };
put(v);
cv::GRunArgs out_v = get<cv::GRunArgs>();
cv::Scalar out_scalar1 = cv::util::get<cv::Scalar>(out_v[0]);
cv::Scalar out_scalar2 = cv::util::get<cv::Scalar>(out_v[1]);
EXPECT_EQ(scalar1, out_scalar1);
EXPECT_EQ(scalar2, out_scalar2);
}
TEST_F(S11N_Basic, Test_RunArg_Opaque) {
auto op = cv::detail::OpaqueRef(42);
auto v = cv::GRunArg{ op };
put(v);
cv::GRunArg out_v = get<cv::GRunArg>();
cv::detail::OpaqueRef out_op = cv::util::get<cv::detail::OpaqueRef>(out_v);
EXPECT_TRUE(operator==<int>(op, out_op));
}
TEST_F(S11N_Basic, Test_RunArgs_Opaque) {
cv::detail::OpaqueRef op1 = cv::detail::OpaqueRef(cv::Point(1, 2));
cv::detail::OpaqueRef op2 = cv::detail::OpaqueRef(cv::Size(12, 21));
GRunArgs v;
v.resize(2);
v[0] = cv::GRunArg{ op1 };
v[1] = cv::GRunArg{ op2 };
put(v);
cv::GRunArgs out_v = get<cv::GRunArgs>();
cv::detail::OpaqueRef out_op1 = cv::util::get<cv::detail::OpaqueRef>(out_v[0]);
cv::detail::OpaqueRef out_op2 = cv::util::get<cv::detail::OpaqueRef>(out_v[1]);
EXPECT_TRUE(operator==<cv::Point>(op1, out_op1));
EXPECT_TRUE(operator==<cv::Size>(op2, out_op2));
}
TEST_F(S11N_Basic, Test_RunArg_Array) {
auto op = cv::detail::VectorRef(std::vector<cv::Mat>{cv::Mat::eye(3, 3, CV_8UC1), cv::Mat::zeros(5, 5, CV_8UC3)});
auto v = cv::GRunArg{ op };
put(v);
cv::GRunArg out_v = get<cv::GRunArg>();
cv::detail::VectorRef out_op = cv::util::get<cv::detail::VectorRef>(out_v);
auto vec1 = op.rref<cv::Mat>();
auto vec2 = out_op.rref<cv::Mat>();
EXPECT_EQ(0, cv::norm(vec1[0], vec2[0], cv::NORM_INF));
EXPECT_EQ(0, cv::norm(vec1[1], vec2[1], cv::NORM_INF));
}
TEST_F(S11N_Basic, Test_RunArgs_Array) {
auto vec_sc = std::vector<cv::Scalar>{cv::Scalar(11), cv::Scalar(31)};
auto vec_d = std::vector<double>{0.4, 1.0, 123.55, 22.08};
cv::detail::VectorRef op1 = cv::detail::VectorRef(vec_sc);
cv::detail::VectorRef op2 = cv::detail::VectorRef(vec_d);
GRunArgs v;
v.resize(2);
v[0] = cv::GRunArg{ op1 };
v[1] = cv::GRunArg{ op2 };
put(v);
cv::GRunArgs out_v = get<cv::GRunArgs>();
cv::detail::VectorRef out_op1 = cv::util::get<cv::detail::VectorRef>(out_v[0]);
cv::detail::VectorRef out_op2 = cv::util::get<cv::detail::VectorRef>(out_v[1]);
EXPECT_TRUE(operator==<cv::Scalar>(op1, out_op1));
EXPECT_TRUE(operator==<double>(op2, out_op2));
}
TEST_F(S11N_Basic, Test_RunArgs_MatScalar) {
cv::Mat mat = cv::Mat::eye(cv::Size(64, 64), CV_8UC3);
cv::Scalar scalar = cv::Scalar(128, 33, 53);
GRunArgs v;
v.resize(2);
v[0] = cv::GRunArg{ mat };
v[1] = cv::GRunArg{ scalar };
put(v);
cv::GRunArgs out_v = get<cv::GRunArgs>();
unsigned int i = 0;
for (auto it : out_v)
{
using T = cv::GRunArg;
switch (it.index())
{
case T::index_of<cv::Mat>() :
{
cv::Mat out_mat = cv::util::get<cv::Mat>(out_v[i]);
EXPECT_EQ(0, cv::norm(mat, out_mat, cv::NORM_INF));
} break;
case T::index_of<cv::Scalar>() :
{
cv::Scalar out_scalar = cv::util::get<cv::Scalar>(out_v[i]);
EXPECT_EQ(scalar, out_scalar);
} break;
default:
GAPI_Assert(false && "This value type is not supported!"); // ...maybe because of STANDALONE mode.
break;
}
i++;
}
}
TEST_F(S11N_Basic, Test_Bind_RunArgs_MatScalar) {
cv::Mat mat = cv::Mat::eye(cv::Size(128, 64), CV_8UC3);
cv::Scalar scalar = cv::Scalar(128, 33, 53);
GRunArgs v;
v.resize(2);
v[0] = cv::GRunArg{ mat };
v[1] = cv::GRunArg{ scalar };
GRunArgsP output = cv::gapi::bind(v);
unsigned int i = 0;
for (auto it : output)
{
using T = cv::GRunArgP;
switch (it.index())
{
case T::index_of<cv::Mat*>() :
{
cv::Mat* out_mat = cv::util::get<cv::Mat*>(it);
EXPECT_EQ(mat.size(), out_mat->size());
} break;
case T::index_of<cv::Scalar*>() :
{
cv::Scalar* out_scalar = cv::util::get<cv::Scalar*>(it);
EXPECT_EQ(out_scalar->val[0], scalar.val[0]);
EXPECT_EQ(out_scalar->val[1], scalar.val[1]);
EXPECT_EQ(out_scalar->val[2], scalar.val[2]);
} break;
default:
GAPI_Assert(false && "This value type is not supported!"); // ...maybe because of STANDALONE mode.
break;
}
i++;
}
}
TEST_F(S11N_Basic, Test_RunArg_RMat) {
cv::Mat mat = cv::Mat::eye(cv::Size(128, 64), CV_8UC3);
cv::RMat rmat = cv::make_rmat<MyRMatAdapter>(mat, 42, "It actually works");
auto v = cv::GRunArgs{ cv::GRunArg{ rmat } };
const std::vector<char> sargsin = cv::gapi::serialize(v);
cv::GRunArgs out = cv::gapi::deserialize<cv::GRunArgs, MyRMatAdapter>(sargsin);
cv::RMat out_mat = cv::util::get<cv::RMat>(out[0]);
auto adapter = out_mat.get<MyRMatAdapter>();
EXPECT_EQ(42, adapter->getVal());
EXPECT_EQ("It actually works", adapter->getStr());
}
TEST_F(S11N_Basic, Test_RunArg_RMat_Scalar_Mat) {
cv::Mat mat = cv::Mat::eye(cv::Size(128, 64), CV_8UC3);
cv::RMat rmat = cv::make_rmat<MyRMatAdapter>(mat, 42, "It actually works");
cv::Scalar sc(111);
auto v = cv::GRunArgs{ cv::GRunArg{ rmat }, cv::GRunArg{ sc }, cv::GRunArg{ mat } };
const std::vector<char> sargsin = cv::gapi::serialize(v);
cv::GRunArgs out = cv::gapi::deserialize<cv::GRunArgs, MyRMatAdapter>(sargsin);
cv::RMat out_rmat = cv::util::get<cv::RMat>(out[0]);
auto adapter = out_rmat.get<MyRMatAdapter>();
EXPECT_EQ(42, adapter->getVal());
EXPECT_EQ("It actually works", adapter->getStr());
cv::Scalar out_sc = cv::util::get<cv::Scalar>(out[1]);
EXPECT_EQ(sc, out_sc);
cv::Mat out_mat = cv::util::get<cv::Mat>(out[2]);
EXPECT_EQ(0, cv::norm(mat, out_mat));
}
namespace {
template <cv::detail::OpaqueKind K, typename T>
bool verifyOpaqueKind(T&& in) {
auto inObjs = cv::gin(in);
auto in_o_ref = cv::util::get<cv::detail::OpaqueRef>(inObjs[0]);
return K == in_o_ref.getKind();
}
template <cv::detail::OpaqueKind K, typename T>
bool verifyArrayKind(T&& in) {
auto inObjs = cv::gin(in);
auto in_o_ref = cv::util::get<cv::detail::VectorRef>(inObjs[0]);
return K == in_o_ref.getKind();
}
}
TEST_F(S11N_Basic, Test_Gin_GOpaque) {
int i; float f; double d;
std::uint64_t ui; bool b;
std::string s;
cv::Rect r; cv::Size sz;
cv::Point p;
EXPECT_TRUE(verifyOpaqueKind<cv::detail::OpaqueKind::CV_INT>(i));
EXPECT_TRUE(verifyOpaqueKind<cv::detail::OpaqueKind::CV_FLOAT>(f));
EXPECT_TRUE(verifyOpaqueKind<cv::detail::OpaqueKind::CV_DOUBLE>(d));
EXPECT_TRUE(verifyOpaqueKind<cv::detail::OpaqueKind::CV_UINT64>(ui));
EXPECT_TRUE(verifyOpaqueKind<cv::detail::OpaqueKind::CV_BOOL>(b));
EXPECT_TRUE(verifyOpaqueKind<cv::detail::OpaqueKind::CV_STRING>(s));
EXPECT_TRUE(verifyOpaqueKind<cv::detail::OpaqueKind::CV_RECT>(r));
EXPECT_TRUE(verifyOpaqueKind<cv::detail::OpaqueKind::CV_SIZE>(sz));
EXPECT_TRUE(verifyOpaqueKind<cv::detail::OpaqueKind::CV_POINT>(p));
}
TEST_F(S11N_Basic, Test_Gin_GArray) {
std::vector<int> i; std::vector<float> f; std::vector<double> d;
std::vector<std::uint64_t> ui; std::vector<bool> b;
std::vector<std::string> s;
std::vector<cv::Rect> r; std::vector<cv::Size> sz;
std::vector<cv::Point> p;
std::vector<cv::Mat> mat;
std::vector<cv::Scalar> sc;
EXPECT_TRUE(verifyArrayKind<cv::detail::OpaqueKind::CV_INT>(i));
EXPECT_TRUE(verifyArrayKind<cv::detail::OpaqueKind::CV_FLOAT>(f));
EXPECT_TRUE(verifyArrayKind<cv::detail::OpaqueKind::CV_DOUBLE>(d));
EXPECT_TRUE(verifyArrayKind<cv::detail::OpaqueKind::CV_UINT64>(ui));
EXPECT_TRUE(verifyArrayKind<cv::detail::OpaqueKind::CV_BOOL>(b));
EXPECT_TRUE(verifyArrayKind<cv::detail::OpaqueKind::CV_STRING>(s));
EXPECT_TRUE(verifyArrayKind<cv::detail::OpaqueKind::CV_RECT>(r));
EXPECT_TRUE(verifyArrayKind<cv::detail::OpaqueKind::CV_SIZE>(sz));
EXPECT_TRUE(verifyArrayKind<cv::detail::OpaqueKind::CV_POINT>(p));
EXPECT_TRUE(verifyArrayKind<cv::detail::OpaqueKind::CV_MAT>(mat));
EXPECT_TRUE(verifyArrayKind<cv::detail::OpaqueKind::CV_SCALAR>(sc));
}
TEST_F(S11N_Basic, Test_Custom_Type) {
MyCustomType var{1324, "Hello", {1920, 1080, 720}, {{1, 2937459432}, {42, 253245432}}};
cv::gapi::s11n::ByteMemoryOutStream os;
cv::gapi::s11n::detail::S11N<MyCustomType>::serialize(os, var);
cv::gapi::s11n::ByteMemoryInStream is(os.data());
MyCustomType new_var = cv::gapi::s11n::detail::S11N<MyCustomType>::deserialize(is);
EXPECT_EQ(var, new_var);
}
TEST_F(S11N_Basic, Test_CompileArg) {
MyCustomType customVar{1248, "World", {1280, 720, 640, 480}, {{5, 32434142342}, {7, 34242432}}};
std::vector<char> sArgs = cv::gapi::serialize(cv::compile_args(customVar));
GCompileArgs dArgs = cv::gapi::deserialize<GCompileArgs, MyCustomType>(sArgs);
MyCustomType dCustomVar = cv::gapi::getCompileArg<MyCustomType>(dArgs).value();
EXPECT_EQ(customVar, dCustomVar);
}
TEST_F(S11N_Basic, Test_CompileArg_Without_UserCallback) {
SimpleCustomType customVar1 { false };
MyCustomTypeNoS11N customVar2 { 'z', 189, "Name" };
MyCustomType customVar3 { 1248, "World", {1280, 720, 640, 480},
{{5, 32434142342}, {7, 34242432}} };
EXPECT_NO_THROW(cv::gapi::serialize(cv::compile_args(customVar1, customVar2, customVar3)));
std::vector<char> sArgs = cv::gapi::serialize(
cv::compile_args(customVar1, customVar2, customVar3));
GCompileArgs dArgs = cv::gapi::deserialize<GCompileArgs,
SimpleCustomType,
MyCustomType>(sArgs);
SimpleCustomType dCustomVar1 = cv::gapi::getCompileArg<SimpleCustomType>(dArgs).value();
MyCustomType dCustomVar3 = cv::gapi::getCompileArg<MyCustomType>(dArgs).value();
EXPECT_EQ(customVar1, dCustomVar1);
EXPECT_EQ(customVar3, dCustomVar3);
}
TEST_F(S11N_Basic, Test_Deserialize_Only_Requested_CompileArgs) {
MyCustomType myCustomVar { 1248, "World", {1280, 720, 640, 480},
{{5, 32434142342}, {7, 34242432}} };
SimpleCustomType simpleCustomVar { false };
std::vector<char> sArgs = cv::gapi::serialize(cv::compile_args(myCustomVar, simpleCustomVar));
GCompileArgs dArgs = cv::gapi::deserialize<GCompileArgs, MyCustomType>(sArgs);
EXPECT_EQ(1u, dArgs.size());
EXPECT_EQ(myCustomVar, cv::gapi::getCompileArg<MyCustomType>(dArgs).value());
dArgs.clear();
dArgs = cv::gapi::deserialize<GCompileArgs, SimpleCustomType>(sArgs);
EXPECT_EQ(1u, dArgs.size());
EXPECT_EQ(simpleCustomVar, cv::gapi::getCompileArg<SimpleCustomType>(dArgs).value());
dArgs.clear();
dArgs = cv::gapi::deserialize<GCompileArgs, SimpleCustomType2>(sArgs);
EXPECT_EQ(0u, dArgs.size());
dArgs.clear();
dArgs = cv::gapi::deserialize<GCompileArgs, MyCustomType, SimpleCustomType>(sArgs);
EXPECT_EQ(2u, dArgs.size());
EXPECT_EQ(myCustomVar, cv::gapi::getCompileArg<MyCustomType>(dArgs).value());
EXPECT_EQ(simpleCustomVar, cv::gapi::getCompileArg<SimpleCustomType>(dArgs).value());
SimpleCustomType2 simpleCustomVar2 { 5 };
std::vector<char> sArgs2 = cv::gapi::serialize(
cv::compile_args(myCustomVar, simpleCustomVar, simpleCustomVar2));
GCompileArgs dArgs2 = cv::gapi::deserialize<GCompileArgs,
MyCustomType,
SimpleCustomType2>(sArgs2);
EXPECT_EQ(2u, dArgs2.size());
EXPECT_EQ(myCustomVar, cv::gapi::getCompileArg<MyCustomType>(dArgs2).value());
EXPECT_EQ(simpleCustomVar2, cv::gapi::getCompileArg<SimpleCustomType2>(dArgs2).value());
}
TEST_F(S11N_Basic, Test_Deserialize_CompileArgs_RandomOrder) {
SimpleCustomType simpleCustomVar { false };
SimpleCustomType2 simpleCustomVar2 { 5 };
std::vector<char> sArgs = cv::gapi::serialize(
cv::compile_args(simpleCustomVar, simpleCustomVar2));
GCompileArgs dArgs = cv::gapi::deserialize<GCompileArgs,
// Here, types of passed to serialize() arguments
// are enumerated in reverse order
SimpleCustomType2,
SimpleCustomType>(sArgs);
EXPECT_EQ(simpleCustomVar, cv::gapi::getCompileArg<SimpleCustomType>(dArgs).value());
EXPECT_EQ(simpleCustomVar2, cv::gapi::getCompileArg<SimpleCustomType2>(dArgs).value());
}
TEST_F(S11N_Basic, Test_CompileArgs_With_EmptyCompileArg) {
MyCustomType myCustomVar { 1248, "World", {1280, 720, 640, 480},
{{5, 32434142342}, {7, 34242432}} };
SimpleCustomType simpleCustomVar { false };
EmptyCustomType emptyCustomVar { };
//----{ emptyCustomVar, myCustomVar }----
std::vector<char> sArgs1 = cv::gapi::serialize(cv::compile_args(emptyCustomVar, myCustomVar));
GCompileArgs dArgsEmptyVar1 = cv::gapi::deserialize<GCompileArgs, EmptyCustomType>(sArgs1);
GCompileArgs dArgsMyVar1 = cv::gapi::deserialize<GCompileArgs, MyCustomType>(sArgs1);
GCompileArgs dArgsEmptyAndMyVars1 = cv::gapi::deserialize<GCompileArgs,
EmptyCustomType,
MyCustomType>(sArgs1);
EXPECT_EQ(1u, dArgsEmptyVar1.size());
EXPECT_TRUE(cv::gapi::getCompileArg<EmptyCustomType>(dArgsEmptyVar1).has_value());
EXPECT_EQ(1u, dArgsMyVar1.size());
EXPECT_EQ(myCustomVar, cv::gapi::getCompileArg<MyCustomType>(dArgsMyVar1).value());
EXPECT_EQ(2u, dArgsEmptyAndMyVars1.size());
EXPECT_TRUE(cv::gapi::getCompileArg<EmptyCustomType>(dArgsEmptyAndMyVars1).has_value());
EXPECT_EQ(myCustomVar, cv::gapi::getCompileArg<MyCustomType>(dArgsEmptyAndMyVars1).value());
//----{ myCustomVar, emptyCustomVar }----
std::vector<char> sArgs2 = cv::gapi::serialize(cv::compile_args(myCustomVar, emptyCustomVar));
GCompileArgs dArgsMyVar2 = cv::gapi::deserialize<GCompileArgs, MyCustomType>(sArgs2);
GCompileArgs dArgsEmptyVar2 = cv::gapi::deserialize<GCompileArgs, EmptyCustomType>(sArgs2);
GCompileArgs dArgsMyAndEmptyVars2 = cv::gapi::deserialize<GCompileArgs,
MyCustomType,
EmptyCustomType>(sArgs2);
EXPECT_EQ(1u, dArgsMyVar2.size());
EXPECT_EQ(myCustomVar, cv::gapi::getCompileArg<MyCustomType>(dArgsMyVar2).value());
EXPECT_EQ(1u, dArgsEmptyVar2.size());
EXPECT_TRUE(cv::gapi::getCompileArg<EmptyCustomType>(dArgsEmptyVar2).has_value());
EXPECT_EQ(2u, dArgsMyAndEmptyVars2.size());
EXPECT_EQ(myCustomVar, cv::gapi::getCompileArg<MyCustomType>(dArgsMyAndEmptyVars2).value());
EXPECT_TRUE(cv::gapi::getCompileArg<EmptyCustomType>(dArgsMyAndEmptyVars2).has_value());
//----{ myCustomVar, emptyCustomVar, simpleCustomVar }----
std::vector<char> sArgs3 = cv::gapi::serialize(
cv::compile_args(myCustomVar, emptyCustomVar, simpleCustomVar));
GCompileArgs dArgsMyVar3 = cv::gapi::deserialize<GCompileArgs, MyCustomType>(sArgs3);
GCompileArgs dArgsEmptyVar3 = cv::gapi::deserialize<GCompileArgs, EmptyCustomType>(sArgs3);
GCompileArgs dArgsSimpleVar3 = cv::gapi::deserialize<GCompileArgs, SimpleCustomType>(sArgs3);
GCompileArgs dArgsMyAndSimpleVars3 = cv::gapi::deserialize<GCompileArgs,
MyCustomType,
SimpleCustomType>(sArgs3);
GCompileArgs dArgs3 = cv::gapi::deserialize<GCompileArgs,
MyCustomType,
EmptyCustomType,
SimpleCustomType>(sArgs3);
EXPECT_EQ(1u, dArgsMyVar3.size());
EXPECT_EQ(myCustomVar, cv::gapi::getCompileArg<MyCustomType>(dArgsMyVar3).value());
EXPECT_EQ(1u, dArgsEmptyVar3.size());
EXPECT_TRUE(cv::gapi::getCompileArg<EmptyCustomType>(dArgsEmptyVar3).has_value());
EXPECT_EQ(1u, dArgsSimpleVar3.size());
EXPECT_EQ(simpleCustomVar, cv::gapi::getCompileArg<SimpleCustomType>(dArgsSimpleVar3).value());
EXPECT_EQ(2u, dArgsMyAndSimpleVars3.size());
EXPECT_EQ(myCustomVar, cv::gapi::getCompileArg<MyCustomType>(dArgsMyAndSimpleVars3).value());
EXPECT_EQ(simpleCustomVar,
cv::gapi::getCompileArg<SimpleCustomType>(dArgsMyAndSimpleVars3).value());
EXPECT_EQ(3u, dArgs3.size());
EXPECT_EQ(myCustomVar, cv::gapi::getCompileArg<MyCustomType>(dArgs3).value());
EXPECT_TRUE(cv::gapi::getCompileArg<EmptyCustomType>(dArgs3).has_value());
EXPECT_EQ(simpleCustomVar, cv::gapi::getCompileArg<SimpleCustomType>(dArgs3).value());
//----{ emptyCustomVar }----
std::vector<char> sArgs4 = cv::gapi::serialize(cv::compile_args(emptyCustomVar));
GCompileArgs dArgsEmptyVar4 = cv::gapi::deserialize<GCompileArgs, EmptyCustomType>(sArgs4);
EXPECT_EQ(1u, dArgsEmptyVar4.size());
EXPECT_TRUE(cv::gapi::getCompileArg<EmptyCustomType>(dArgsEmptyVar4).has_value());
}
} // namespace opencv_test
Reference in New Issue View Git Blame Copy Permalink