>;
using GRunArgsP = std::vector<GRunArgP>;
+namespace gapi
+{
+ GAPI_EXPORTS cv::GRunArgsP bind(cv::GRunArgs &results);
+}
+
template<typename... Ts> inline GRunArgs gin(const Ts&... args)
{
return GRunArgs{ GRunArg(detail::wrap_host_helper<Ts>::wrap_in(args))... };
GAPI_EXPORTS cv::GComputation getGraph(const std::vector<char> &p);
} // namespace detail
+namespace detail {
+ GAPI_EXPORTS cv::GMetaArgs getMetaArgs(const std::vector<char> &p);
+} // namespace detail
+
+namespace detail {
+ GAPI_EXPORTS cv::GRunArgs getRunArgs(const std::vector<char> &p);
+} // namespace detail
+
GAPI_EXPORTS std::vector<char> serialize(const cv::GComputation &c);
//namespace{
//} //ananymous namespace
+GAPI_EXPORTS std::vector<char> serialize(const cv::GMetaArgs&);
+GAPI_EXPORTS std::vector<char> serialize(const cv::GRunArgs&);
+
template<> inline
cv::GComputation deserialize(const std::vector<char> &p) {
return detail::getGraph(p);
}
+template<> inline
+cv::GMetaArgs deserialize(const std::vector<char> &p) {
+ return detail::getMetaArgs(p);
+}
+
+template<> inline
+cv::GRunArgs deserialize(const std::vector<char> &p) {
+ return detail::getRunArgs(p);
+}
} // namespace gapi
// Copyright (C) 2020 Intel Corporation
#include <opencv2/gapi/s11n.hpp>
+#include <opencv2/gapi/garg.hpp>
#include "backends/common/serialization.hpp"
cv::gimpl::s11n::ByteMemoryInStream is(p);
return cv::GComputation(is);
}
+
+cv::GMetaArgs cv::gapi::detail::getMetaArgs(const std::vector<char> &p) {
+ cv::gimpl::s11n::ByteMemoryInStream is(p);
+ return meta_args_deserialize(is);
+}
+
+cv::GRunArgs cv::gapi::detail::getRunArgs(const std::vector<char> &p) {
+ cv::gimpl::s11n::ByteMemoryInStream is(p);
+ return run_args_deserialize(is);
+}
+
+std::vector<char> cv::gapi::serialize(const cv::GMetaArgs& ma)
+{
+ cv::gimpl::s11n::ByteMemoryOutStream os;
+ serialize(os, ma);
+ return os.data();
+}
+
+std::vector<char> cv::gapi::serialize(const cv::GRunArgs& ra)
+{
+ cv::gimpl::s11n::ByteMemoryOutStream os;
+ serialize(os, ra);
+ return os.data();
+}
+
+cv::GRunArgsP cv::gapi::bind(cv::GRunArgs &results)
+{
+ cv::GRunArgsP outputs;
+ outputs.reserve(results.size());
+ for (cv::GRunArg &res_obj : results)
+ {
+ using T = cv::GRunArg;
+ switch (res_obj.index())
+ {
+#if !defined(GAPI_STANDALONE)
+ case T::index_of<cv::UMat>() :
+ outputs.emplace_back((cv::UMat*)(&(cv::util::get<cv::UMat>(res_obj))));
+ break;
+#endif
+ case cv::GRunArg::index_of<cv::Mat>() :
+ outputs.emplace_back((cv::Mat*)(&(cv::util::get<cv::Mat>(res_obj))));
+ break;
+ case cv::GRunArg::index_of<cv::Scalar>() :
+ outputs.emplace_back((cv::Scalar*)(&(cv::util::get<cv::Scalar>(res_obj))));
+ break;
+ case T::index_of<cv::detail::VectorRef>() :
+ outputs.emplace_back(cv::util::get<cv::detail::VectorRef>(res_obj));
+ break;
+ case T::index_of<cv::detail::OpaqueRef>() :
+ outputs.emplace_back(cv::util::get<cv::detail::OpaqueRef>(res_obj));
+ break;
+ default:
+ GAPI_Assert(false && "This value type is not supported!"); // ...maybe because of STANDALONE mode.
+ break;
+ }
+ }
+ return outputs;
+}
I::OStream& operator<< (I::OStream& os, const cv::GArrayDesc &) {return os;}
I::IStream& operator>> (I::IStream& is, cv::GArrayDesc &) {return is;}
+#if !defined(GAPI_STANDALONE)
+I::OStream& operator<< (I::OStream& os, const cv::UMat &)
+{
+ GAPI_Assert(false && "Serialization: Unsupported << for UMat");
+ return os;
+}
+I::IStream& operator >> (I::IStream& is, cv::UMat &)
+{
+ GAPI_Assert(false && "Serialization: Unsupported >> for UMat");
+ return is;
+}
+#endif // !defined(GAPI_STANDALONE)
+
+I::OStream& operator<< (I::OStream& os, const cv::gapi::wip::IStreamSource::Ptr &)
+{
+ GAPI_Assert(false && "Serialization: Unsupported << for IStreamSource::Ptr");
+ return os;
+}
+I::IStream& operator >> (I::IStream& is, cv::gapi::wip::IStreamSource::Ptr &)
+{
+ GAPI_Assert("Serialization: Unsupported >> for IStreamSource::Ptr");
+ return is;
+}
+
+I::OStream& operator<< (I::OStream& os, const cv::detail::VectorRef &)
+{
+ GAPI_Assert(false && "Serialization: Unsupported << for cv::detail::VectorRef &");
+ return os;
+}
+I::IStream& operator >> (I::IStream& is, cv::detail::VectorRef &)
+{
+ GAPI_Assert(false && "Serialization: Unsupported >> for cv::detail::VectorRef &");
+ return is;
+}
+
+I::OStream& operator<< (I::OStream& os, const cv::detail::OpaqueRef &)
+{
+ GAPI_Assert(false && "Serialization: Unsupported << for cv::detail::OpaqueRef &");
+ return os;
+}
+I::IStream& operator >> (I::IStream& is, cv::detail::OpaqueRef &)
+{
+ GAPI_Assert(false && "Serialization: Unsupported >> for cv::detail::OpaqueRef &");
+ return is;
+}
// Enums and structures
namespace {
return is;
}
-
I::OStream& operator<< (I::OStream& os, const cv::GKernel &k) {
return os << k.name << k.tag << k.outShapes;
}
return *this;
}
+GAPI_EXPORTS void serialize(I::OStream& os, const cv::GMetaArgs &ma) {
+ os << ma;
+}
+GAPI_EXPORTS void serialize(I::OStream& os, const cv::GRunArgs &ra) {
+ os << ra;
+}
+GAPI_EXPORTS GMetaArgs meta_args_deserialize(I::IStream& is) {
+ GMetaArgs s;
+ is >> s;
+ return s;
+}
+GAPI_EXPORTS GRunArgs run_args_deserialize(I::IStream& is) {
+ GRunArgs s;
+ is >> s;
+ return s;
+}
+
+
} // namespace s11n
} // namespace gimpl
} // namespace cv
#include "compiler/gmodel.hpp"
+#if (defined _WIN32 || defined _WIN64) && defined _MSC_VER
+#pragma warning(disable: 4702)
+#endif
+
namespace cv {
namespace gimpl {
namespace s11n {
GAPI_EXPORTS I::OStream& operator<< (I::OStream& os, const cv::Mat &m);
GAPI_EXPORTS I::IStream& operator>> (I::IStream& is, cv::Mat &m);
+
+
// G-API types /////////////////////////////////////////////////////////////////
GAPI_EXPORTS I::OStream& operator<< (I::OStream& os, cv::util::monostate );
GAPI_EXPORTS I::OStream& operator<< (I::OStream& os, const cv::GArg &arg);
GAPI_EXPORTS I::IStream& operator>> (I::IStream& is, cv::GArg &arg);
+//Forward declaration
+//I::OStream& operator<< (I::OStream& os, const cv::GRunArg &arg);
+//I::IStream& operator>> (I::IStream& is, cv::GRunArg &arg);
+
+
GAPI_EXPORTS I::OStream& operator<< (I::OStream& os, const cv::GKernel &k);
GAPI_EXPORTS I::IStream& operator>> (I::IStream& is, cv::GKernel &k);
GAPI_EXPORTS I::OStream& operator<< (I::OStream& os, const cv::GArrayDesc &);
GAPI_EXPORTS I::IStream& operator>> (I::IStream& is, cv::GArrayDesc &);
+#if !defined(GAPI_STANDALONE)
+GAPI_EXPORTS I::OStream& operator<< (I::OStream& os, const cv::UMat &);
+GAPI_EXPORTS I::IStream& operator>> (I::IStream& is, cv::UMat &);
+#endif // !defined(GAPI_STANDALONE)
+
+GAPI_EXPORTS I::OStream& operator<< (I::OStream& os, const cv::gapi::wip::IStreamSource::Ptr &);
+GAPI_EXPORTS I::IStream& operator>> (I::IStream& is, cv::gapi::wip::IStreamSource::Ptr &);
+
+GAPI_EXPORTS I::OStream& operator<< (I::OStream& os, const cv::detail::VectorRef &);
+GAPI_EXPORTS I::IStream& operator>> (I::IStream& is, cv::detail::VectorRef &);
+
+GAPI_EXPORTS I::OStream& operator<< (I::OStream& os, const cv::detail::OpaqueRef &);
+GAPI_EXPORTS I::IStream& operator>> (I::IStream& is, cv::detail::OpaqueRef &);
+
GAPI_EXPORTS I::OStream& operator<< (I::OStream& os, const cv::gimpl::RcDesc &rc);
GAPI_EXPORTS I::IStream& operator>> (I::IStream& is, cv::gimpl::RcDesc &rc);
GAPI_EXPORTS void reconstruct(const GSerialized &s, ade::Graph &g);
// Legacy //////////////////////////////////////////////////////////////////////
-
-
-// Generic: vector serialization ///////////////////////////////////////////////
-template<typename T>
-I::OStream& operator<< (I::OStream& os, const std::vector<T> &ts) {
- //const std::size_t sz = ts.size(); // explicitly specify type
- const uint32_t sz = (uint32_t)ts.size(); // explicitly specify type
- os << sz;
- for (auto &&v : ts) os << v;
- return os;
-}
-template<typename T>
-I::IStream& operator>> (I::IStream& is, std::vector<T> &ts) {
- //std::size_t sz = 0u;
- uint32_t sz = 0u;
- is >> sz;
- if (sz == 0u) {
- ts.clear();
- } else {
- ts.resize(sz);
- for (auto &&i : ade::util::iota(sz)) is >> ts[i];
- }
- return is;
-}
-
// Generic: unordered_map serialization ////////////////////////////////////////
template<typename K, typename V>
I::OStream& operator<< (I::OStream& os, const std::unordered_map<K, V> &m) {
return detail::get_v<cv::util::variant<Ts...>, Ts...>(is, v, 0u, idx);
}
+// Generic: vector serialization ///////////////////////////////////////////////
+// Moved here to fix CLang issues https://clang.llvm.org/compatibility.html
+// Unqualified lookup in templates
+template<typename T>
+I::OStream& operator<< (I::OStream& os, const std::vector<T> &ts) {
+ //const std::size_t sz = ts.size(); // explicitly specify type
+ const uint32_t sz = (uint32_t)ts.size(); // explicitly specify type
+ os << sz;
+ for (auto &&v : ts) os << v;
+ return os;
+}
+template<typename T>
+I::IStream& operator >> (I::IStream& is, std::vector<T> &ts) {
+ //std::size_t sz = 0u;
+ uint32_t sz = 0u;
+ is >> sz;
+ if (sz == 0u) {
+ ts.clear();
+ }
+ else {
+ ts.resize(sz);
+ for (auto &&i : ade::util::iota(sz)) is >> ts[i];
+ }
+ return is;
+}
+
// FIXME: Basic Stream implementaions //////////////////////////////////////////
// Basic in-memory stream implementations.
virtual I::IStream& operator>> (std::string &) override;
};
+GAPI_EXPORTS void serialize(I::OStream& os, const cv::GMetaArgs &ma);
+GAPI_EXPORTS void serialize(I::OStream& os, const cv::GRunArgs &ra);
+GAPI_EXPORTS GMetaArgs meta_args_deserialize(I::IStream& is);
+GAPI_EXPORTS GRunArgs run_args_deserialize(I::IStream& is);
} // namespace s11n
} // namespace gimpl
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_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);
+ std::cout << "output size " << output.size() << std::endl;
+ 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++;
+ }
+}
+
} // namespace opencv_test
projects / platform / upstream / opencv.git / commitdiff