mirror/opencv
1
0
Fork 0
mirror of https://github.com/opencv/opencv.git synced 2024-11-28 05:06:29 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge pull request #16995 from mpashchenkov:mp/ocv-gapi-standalone-mat

Browse Source 
G-API: Mat's "deownification"

* deowned Mat

* boner

* Removed canDescribe test for own::Mat

* Removed STANDALONE flag for apply() and operator()

* Removed: desc_tests for own::Mat, descr_of for own::Mat.

* Returned: tests, cv::gapi::own::descr_of; fixed alignment; Removed own::Mat's headers

* Removed unused header own/mat.hpp from gbackend.hpp
This commit is contained in:
Maxim Pashchenkov 2020-04-21 23:22:01 +03:00 committed by GitHub
parent f19d0ae41d
commit 94e36d8c8d
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
31 changed files with 108 additions and 270 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
modules/gapi/include/opencv2/gapi/cpu/gcpukernel.hpp
View File

@ -17,7 +17,6 @@
#include <opencv2/gapi/gcommon.hpp> #include <opencv2/gapi/gcommon.hpp>
#include <opencv2/gapi/gkernel.hpp> #include <opencv2/gapi/gkernel.hpp>
#include <opencv2/gapi/garg.hpp> #include <opencv2/gapi/garg.hpp>
#include <opencv2/gapi/own/convert.hpp> //to_ocv
#include <opencv2/gapi/util/compiler_hints.hpp> //suppress_unused_warning #include <opencv2/gapi/util/compiler_hints.hpp> //suppress_unused_warning
#include <opencv2/gapi/util/util.hpp> #include <opencv2/gapi/util/util.hpp>
@ -96,8 +95,8 @@ public:
const T& inArg(int input) { return m_args.at(input).get<T>(); } const T& inArg(int input) { return m_args.at(input).get<T>(); }
// Syntax sugar // Syntax sugar
const cv::gapi::own::Mat& inMat(int input); const cv::Mat& inMat(int input);
cv::gapi::own::Mat& outMatR(int output); // FIXME: Avoid cv::gapi::own::Mat m = ctx.outMatR() cv::Mat& outMatR(int output); // FIXME: Avoid cv::Mat m = ctx.outMatR()
const cv::Scalar& inVal(int input); const cv::Scalar& inVal(int input);
cv::Scalar& outValR(int output); // FIXME: Avoid cv::Scalar s = ctx.outValR() cv::Scalar& outValR(int output); // FIXME: Avoid cv::Scalar s = ctx.outValR()
@ -147,7 +146,7 @@ namespace detail
template<class T> struct get_in; template<class T> struct get_in;
template<> struct get_in<cv::GMat> template<> struct get_in<cv::GMat>
{ {
static cv::Mat get(GCPUContext &ctx, int idx) { return to_ocv(ctx.inMat(idx)); } static cv::Mat get(GCPUContext &ctx, int idx) { return ctx.inMat(idx); }
}; };
template<> struct get_in<cv::GMatP> template<> struct get_in<cv::GMatP>
{ {
@ -196,7 +195,7 @@ template<class T> struct get_in
}; };
struct tracked_cv_mat{ struct tracked_cv_mat{
tracked_cv_mat(cv::gapi::own::Mat& m) : r{to_ocv(m)}, original_data{m.data} {} tracked_cv_mat(cv::Mat& m) : r{m}, original_data{m.data} {}
cv::Mat r; cv::Mat r;
uchar* original_data; uchar* original_data;

4
modules/gapi/include/opencv2/gapi/fluid/gfluidbuffer.hpp
View File

@ -14,11 +14,9 @@
#include <cstdint> // uint8_t #include <cstdint> // uint8_t
#include <opencv2/gapi/opencv_includes.hpp> #include <opencv2/gapi/opencv_includes.hpp>
#include <opencv2/gapi/own/mat.hpp>
#include <opencv2/gapi/gmat.hpp> #include <opencv2/gapi/gmat.hpp>
#include <opencv2/gapi/util/optional.hpp> #include <opencv2/gapi/util/optional.hpp>
#include <opencv2/gapi/own/mat.hpp>
namespace cv { namespace cv {
namespace gapi { namespace gapi {
@ -114,7 +112,7 @@ public:
int wlpi, int wlpi,
BorderOpt border); BorderOpt border);
// Constructor for in/out buffers (for tests) // Constructor for in/out buffers (for tests)
Buffer(const cv::gapi::own::Mat &data, bool is_input); Buffer(const cv::Mat &data, bool is_input);
~Buffer(); ~Buffer();
Buffer& operator=(Buffer&&); Buffer& operator=(Buffer&&);

6
modules/gapi/include/opencv2/gapi/garg.hpp
View File

@ -89,11 +89,10 @@ using GArgs = std::vector<GArg>;
// FIXME: Move to a separate file! // FIXME: Move to a separate file!
using GRunArg = util::variant< using GRunArg = util::variant<
#if !defined(GAPI_STANDALONE) #if !defined(GAPI_STANDALONE)
cv::Mat,
cv::UMat, cv::UMat,
#endif // !defined(GAPI_STANDALONE) #endif // !defined(GAPI_STANDALONE)
cv::gapi::wip::IStreamSource::Ptr, cv::gapi::wip::IStreamSource::Ptr,
cv::gapi::own::Mat, cv::Mat,
cv::Scalar, cv::Scalar,
cv::detail::VectorRef, cv::detail::VectorRef,
cv::detail::OpaqueRef cv::detail::OpaqueRef
@ -122,10 +121,9 @@ struct Data: public GRunArg
using GRunArgP = util::variant< using GRunArgP = util::variant<
#if !defined(GAPI_STANDALONE) #if !defined(GAPI_STANDALONE)
cv::Mat*,
cv::UMat*, cv::UMat*,
#endif // !defined(GAPI_STANDALONE) #endif // !defined(GAPI_STANDALONE)
cv::gapi::own::Mat*, cv::Mat*,
cv::Scalar*, cv::Scalar*,
cv::detail::VectorRef, cv::detail::VectorRef,
cv::detail::OpaqueRef cv::detail::OpaqueRef

4
modules/gapi/include/opencv2/gapi/gcomputation.hpp
View File

@ -250,8 +250,8 @@ public:
void apply(GRunArgs &&ins, GRunArgsP &&outs, GCompileArgs &&args = {}); // Arg-to-arg overload void apply(GRunArgs &&ins, GRunArgsP &&outs, GCompileArgs &&args = {}); // Arg-to-arg overload
/// @private -- Exclude this function from OpenCV documentation /// @private -- Exclude this function from OpenCV documentation
void apply(const std::vector<cv::gapi::own::Mat>& ins, // Compatibility overload void apply(const std::vector<cv::Mat>& ins, // Compatibility overload
const std::vector<cv::gapi::own::Mat>& outs, const std::vector<cv::Mat>& outs,
GCompileArgs &&args = {}); GCompileArgs &&args = {});
// 2. Syntax sugar and compatibility overloads // 2. Syntax sugar and compatibility overloads

13
modules/gapi/include/opencv2/gapi/gmat.hpp
View File

@ -71,10 +71,6 @@ public:
using GMat::GMat; using GMat::GMat;
}; };
namespace gapi { namespace own {
class Mat;
}}//gapi::own
/** @} */ /** @} */
/** /**
@ -121,7 +117,7 @@ struct GAPI_EXPORTS GMatDesc
// (it handles the case when // (it handles the case when
// 1-channel mat can be reinterpreted as is (1-channel mat) // 1-channel mat can be reinterpreted as is (1-channel mat)
// and as a 3-channel planar mat with height divided by 3) // and as a 3-channel planar mat with height divided by 3)
bool canDescribe(const cv::gapi::own::Mat& mat) const; bool canDescribe(const cv::Mat& mat) const;
// Meta combinator: return a new GMatDesc which differs in size by delta // Meta combinator: return a new GMatDesc which differs in size by delta
// (all other fields are taken unchanged from this GMatDesc) // (all other fields are taken unchanged from this GMatDesc)
@ -132,9 +128,6 @@ struct GAPI_EXPORTS GMatDesc
desc.size += delta; desc.size += delta;
return desc; return desc;
} }
#if !defined(GAPI_STANDALONE)
bool canDescribe(const cv::Mat& mat) const;
#endif // !defined(GAPI_STANDALONE)
// Meta combinator: return a new GMatDesc which differs in size by delta // Meta combinator: return a new GMatDesc which differs in size by delta
// (all other fields are taken unchanged from this GMatDesc) // (all other fields are taken unchanged from this GMatDesc)
// //
@ -213,15 +206,15 @@ struct GAPI_EXPORTS GMatDesc
static inline GMatDesc empty_gmat_desc() { return GMatDesc{-1,-1,{-1,-1}}; } static inline GMatDesc empty_gmat_desc() { return GMatDesc{-1,-1,{-1,-1}}; }
#if !defined(GAPI_STANDALONE) #if !defined(GAPI_STANDALONE)
class Mat;
GAPI_EXPORTS GMatDesc descr_of(const cv::Mat &mat);
GAPI_EXPORTS GMatDesc descr_of(const cv::UMat &mat); GAPI_EXPORTS GMatDesc descr_of(const cv::UMat &mat);
#endif // !defined(GAPI_STANDALONE) #endif // !defined(GAPI_STANDALONE)
GAPI_EXPORTS GMatDesc descr_of(const cv::Mat &mat);
/** @} */ /** @} */
// FIXME: WHY??? WHY it is under different namespace? // FIXME: WHY??? WHY it is under different namespace?
namespace gapi { namespace own { namespace gapi { namespace own {
class Mat;
GAPI_EXPORTS GMatDesc descr_of(const Mat &mat); GAPI_EXPORTS GMatDesc descr_of(const Mat &mat);
}}//gapi::own }}//gapi::own

2
modules/gapi/include/opencv2/gapi/gmetaarg.hpp
View File

@ -66,12 +66,10 @@ namespace detail
// Note: descr_of(std::vector<..>) returns a GArrayDesc, while // Note: descr_of(std::vector<..>) returns a GArrayDesc, while
// descrs_of(std::vector<..>) returns an array of Meta args! // descrs_of(std::vector<..>) returns an array of Meta args!
class Mat;
class UMat; class UMat;
GAPI_EXPORTS cv::GMetaArgs descrs_of(const std::vector<cv::Mat> &vec); GAPI_EXPORTS cv::GMetaArgs descrs_of(const std::vector<cv::Mat> &vec);
GAPI_EXPORTS cv::GMetaArgs descrs_of(const std::vector<cv::UMat> &vec); GAPI_EXPORTS cv::GMetaArgs descrs_of(const std::vector<cv::UMat> &vec);
namespace gapi { namespace own { namespace gapi { namespace own {
class Mat;
GAPI_EXPORTS cv::GMetaArgs descrs_of(const std::vector<Mat> &vec); GAPI_EXPORTS cv::GMetaArgs descrs_of(const std::vector<Mat> &vec);
}} // namespace gapi::own }} // namespace gapi::own

4
modules/gapi/include/opencv2/gapi/gtype_traits.hpp
View File

@ -17,7 +17,6 @@
#include <opencv2/gapi/gopaque.hpp> #include <opencv2/gapi/gopaque.hpp>
#include <opencv2/gapi/streaming/source.hpp> #include <opencv2/gapi/streaming/source.hpp>
#include <opencv2/gapi/gcommon.hpp> #include <opencv2/gapi/gcommon.hpp>
#include <opencv2/gapi/own/convert.hpp>
namespace cv namespace cv
{ {
@ -111,10 +110,9 @@ namespace detail
// and GMat behavior is correct for GMatP) // and GMat behavior is correct for GMatP)
template<typename T> struct GTypeOf; template<typename T> struct GTypeOf;
#if !defined(GAPI_STANDALONE) #if !defined(GAPI_STANDALONE)
template<> struct GTypeOf<cv::Mat> { using type = cv::GMat; };
template<> struct GTypeOf<cv::UMat> { using type = cv::GMat; }; template<> struct GTypeOf<cv::UMat> { using type = cv::GMat; };
#endif // !defined(GAPI_STANDALONE) #endif // !defined(GAPI_STANDALONE)
template<> struct GTypeOf<cv::gapi::own::Mat> { using type = cv::GMat; }; template<> struct GTypeOf<cv::Mat> { using type = cv::GMat; };
template<> struct GTypeOf<cv::Scalar> { using type = cv::GScalar; }; template<> struct GTypeOf<cv::Scalar> { using type = cv::GScalar; };
template<typename U> struct GTypeOf<std::vector<U> > { using type = cv::GArray<U>; }; template<typename U> struct GTypeOf<std::vector<U> > { using type = cv::GArray<U>; };
template<typename U> struct GTypeOf { using type = cv::GOpaque<U>;}; template<typename U> struct GTypeOf { using type = cv::GOpaque<U>;};

4
modules/gapi/include/opencv2/gapi/own/cvdefs.hpp
View File

@ -140,10 +140,14 @@ enum InterpolationFlags{
INTER_MAX = 7, INTER_MAX = 7,
}; };
// replacement of cv's structures: // replacement of cv's structures:
namespace gapi { namespace own {
class Mat;
}} // namespace gapi::own
using Rect = gapi::own::Rect; using Rect = gapi::own::Rect;
using Size = gapi::own::Size; using Size = gapi::own::Size;
using Point = gapi::own::Point; using Point = gapi::own::Point;
using Scalar = gapi::own::Scalar; using Scalar = gapi::own::Scalar;
using Mat = gapi::own::Mat;
} // namespace cv } // namespace cv
static inline int cvFloor( double value ) static inline int cvFloor( double value )

75
modules/gapi/src/api/gbackend.cpp
View File

@ -10,7 +10,6 @@
#include <functional> // multiplies #include <functional> // multiplies
#include <opencv2/gapi/gkernel.hpp> #include <opencv2/gapi/gkernel.hpp>
#include <opencv2/gapi/own/convert.hpp>
#include "api/gbackend_priv.hpp" #include "api/gbackend_priv.hpp"
#include "backends/common/gbackend.hpp" #include "backends/common/gbackend.hpp"
@ -114,36 +113,22 @@ void bindInArg(Mag& mag, const RcDesc &rc, const GRunArg &arg, bool is_umat)
{ {
switch (arg.index()) switch (arg.index())
{ {
case GRunArg::index_of<cv::gapi::own::Mat>() : case GRunArg::index_of<cv::Mat>() :
if (is_umat) if (is_umat)
{ {
#if !defined(GAPI_STANDALONE) #if !defined(GAPI_STANDALONE)
auto& mag_umat = mag.template slot<cv::UMat>()[rc.id]; auto& mag_umat = mag.template slot<cv::UMat>()[rc.id];
mag_umat = to_ocv(util::get<cv::gapi::own::Mat>(arg)).getUMat(ACCESS_READ); mag_umat = util::get<cv::Mat>(arg).getUMat(ACCESS_READ);
#else #else
util::throw_error(std::logic_error("UMat is not supported in standalone build")); util::throw_error(std::logic_error("UMat is not supported in standalone build"));
#endif // !defined(GAPI_STANDALONE) #endif // !defined(GAPI_STANDALONE)
} }
else else
{ {
auto& mag_mat = mag.template slot<cv::gapi::own::Mat>()[rc.id]; auto& mag_mat = mag.template slot<cv::Mat>()[rc.id];
mag_mat = util::get<cv::gapi::own::Mat>(arg); mag_mat = util::get<cv::Mat>(arg);
} }
break; break;
#if !defined(GAPI_STANDALONE)
case GRunArg::index_of<cv::Mat>() :
if (is_umat)
{
auto& mag_umat = mag.template slot<cv::UMat>()[rc.id];
mag_umat = util::get<cv::Mat>(arg).getUMat(ACCESS_READ);
}
else
{
auto& mag_mat = mag.template slot<cv::gapi::own::Mat>()[rc.id];
mag_mat = to_own(util::get<cv::Mat>(arg));
}
break;
#endif // !defined(GAPI_STANDALONE)
default: util::throw_error(std::logic_error("content type of the runtime argument does not match to resource description ?")); default: util::throw_error(std::logic_error("content type of the runtime argument does not match to resource description ?"));
} }
break; break;
@ -182,36 +167,22 @@ void bindOutArg(Mag& mag, const RcDesc &rc, const GRunArgP &arg, bool is_umat)
{ {
switch (arg.index()) switch (arg.index())
{ {
case GRunArgP::index_of<cv::gapi::own::Mat*>() : case GRunArgP::index_of<cv::Mat*>() :
if (is_umat) if (is_umat)
{ {
#if !defined(GAPI_STANDALONE) #if !defined(GAPI_STANDALONE)
auto& mag_umat = mag.template slot<cv::UMat>()[rc.id]; auto& mag_umat = mag.template slot<cv::UMat>()[rc.id];
mag_umat = to_ocv(*(util::get<cv::gapi::own::Mat*>(arg))).getUMat(ACCESS_RW); mag_umat = util::get<cv::Mat*>(arg)->getUMat(ACCESS_RW);
#else #else
util::throw_error(std::logic_error("UMat is not supported in standalone build")); util::throw_error(std::logic_error("UMat is not supported in standalone build"));
#endif // !defined(GAPI_STANDALONE) #endif // !defined(GAPI_STANDALONE)
} }
else else
{ {
auto& mag_mat = mag.template slot<cv::gapi::own::Mat>()[rc.id]; auto& mag_mat = mag.template slot<cv::Mat>()[rc.id];
mag_mat = *util::get<cv::gapi::own::Mat*>(arg); mag_mat = *util::get<cv::Mat*>(arg);
} }
break; break;
#if !defined(GAPI_STANDALONE)
case GRunArgP::index_of<cv::Mat*>() :
if (is_umat)
{
auto& mag_umat = mag.template slot<cv::UMat>()[rc.id];
mag_umat = util::get<cv::Mat*>(arg)->getUMat(ACCESS_RW);
}
else
{
auto& mag_mat = mag.template slot<cv::gapi::own::Mat>()[rc.id];
mag_mat = to_own(*util::get<cv::Mat*>(arg));
}
break;
#endif // !defined(GAPI_STANDALONE)
default: util::throw_error(std::logic_error("content type of the runtime argument does not match to resource description ?")); default: util::throw_error(std::logic_error("content type of the runtime argument does not match to resource description ?"));
} }
break; break;
@ -277,7 +248,7 @@ cv::GRunArg getArg(const Mag& mag, const RcDesc &ref)
// Wrap associated CPU object (either host or an internal one) // Wrap associated CPU object (either host or an internal one)
switch (ref.shape) switch (ref.shape)
{ {
case GShape::GMAT: return GRunArg(mag.template slot<cv::gapi::own::Mat>().at(ref.id)); case GShape::GMAT: return GRunArg(mag.template slot<cv::Mat>().at(ref.id));
case GShape::GSCALAR: return GRunArg(mag.template slot<cv::Scalar>().at(ref.id)); case GShape::GSCALAR: return GRunArg(mag.template slot<cv::Scalar>().at(ref.id));
// Note: .at() is intentional for GArray and GOpaque as objects MUST be already there // Note: .at() is intentional for GArray and GOpaque as objects MUST be already there
// (and constructed by either bindIn/Out or resetInternal) // (and constructed by either bindIn/Out or resetInternal)
@ -303,7 +274,7 @@ cv::GRunArgP getObjPtr(Mag& mag, const RcDesc &rc, bool is_umat)
#endif // !defined(GAPI_STANDALONE) #endif // !defined(GAPI_STANDALONE)
} }
else else
return GRunArgP(&mag.template slot<cv::gapi::own::Mat>()[rc.id]); return GRunArgP(&mag.template slot<cv::Mat>()[rc.id]);
case GShape::GSCALAR: return GRunArgP(&mag.template slot<cv::Scalar>()[rc.id]); case GShape::GSCALAR: return GRunArgP(&mag.template slot<cv::Scalar>()[rc.id]);
// Note: .at() is intentional for GArray and GOpaque as objects MUST be already there // Note: .at() is intentional for GArray and GOpaque as objects MUST be already there
// (and constructor by either bindIn/Out or resetInternal) // (and constructor by either bindIn/Out or resetInternal)
@ -347,10 +318,9 @@ void writeBack(const Mag& mag, const RcDesc &rc, GRunArgP &g_arg, bool is_umat)
uchar* out_arg_data = nullptr; uchar* out_arg_data = nullptr;
switch (g_arg.index()) switch (g_arg.index())
{ {
case GRunArgP::index_of<cv::gapi::own::Mat*>() : out_arg_data = util::get<cv::gapi::own::Mat*>(g_arg)->data; break; case GRunArgP::index_of<cv::Mat*>() : out_arg_data = util::get<cv::Mat*>(g_arg)->data; break;
#if !defined(GAPI_STANDALONE) #if !defined(GAPI_STANDALONE)
case GRunArgP::index_of<cv::Mat*>() : out_arg_data = util::get<cv::Mat*>(g_arg)->data; break; case GRunArgP::index_of<cv::UMat*>() : out_arg_data = (util::get<cv::UMat*>(g_arg))->getMat(ACCESS_RW).data; break;
case GRunArgP::index_of<cv::UMat*>() : out_arg_data = (util::get<cv::UMat*>(g_arg))->getMat(ACCESS_RW).data; break;
#endif // !defined(GAPI_STANDALONE) #endif // !defined(GAPI_STANDALONE)
default: util::throw_error(std::logic_error("content type of the runtime argument does not match to resource description ?")); default: util::throw_error(std::logic_error("content type of the runtime argument does not match to resource description ?"));
} }
@ -365,7 +335,7 @@ void writeBack(const Mag& mag, const RcDesc &rc, GRunArgP &g_arg, bool is_umat)
} }
else else
{ {
auto& in_mag = mag.template slot<cv::gapi::own::Mat>().at(rc.id); auto& in_mag = mag.template slot<cv::Mat>().at(rc.id);
GAPI_Assert((out_arg_data == in_mag.data) && " data for output parameters was reallocated ?"); GAPI_Assert((out_arg_data == in_mag.data) && " data for output parameters was reallocated ?");
} }
break; break;
@ -389,24 +359,6 @@ void writeBack(const Mag& mag, const RcDesc &rc, GRunArgP &g_arg, bool is_umat)
} // namespace magazine } // namespace magazine
void createMat(const cv::GMatDesc &desc, cv::gapi::own::Mat& mat)
{
// FIXME: Refactor (probably start supporting N-Dimensional blobs natively
if (desc.dims.empty())
{
const auto type = desc.planar ? desc.depth : CV_MAKETYPE(desc.depth, desc.chan);
const auto size = desc.planar ? cv::Size{desc.size.width, desc.size.height*desc.chan}
: desc.size;
mat.create(size, type);
}
else
{
GAPI_Assert(!desc.planar);
mat.create(desc.dims, desc.depth);
}
}
#if !defined(GAPI_STANDALONE)
void createMat(const cv::GMatDesc &desc, cv::Mat& mat) void createMat(const cv::GMatDesc &desc, cv::Mat& mat)
{ {
// FIXME: Refactor (probably start supporting N-Dimensional blobs natively // FIXME: Refactor (probably start supporting N-Dimensional blobs natively
@ -423,7 +375,6 @@ void createMat(const cv::GMatDesc &desc, cv::Mat& mat)
mat.create(desc.dims, desc.depth); mat.create(desc.dims, desc.depth);
} }
} }
#endif
} // namespace gimpl } // namespace gimpl
} // namespace cv } // namespace cv

8
modules/gapi/src/api/gcomputation.cpp
View File

@ -132,16 +132,16 @@ void cv::GComputation::apply(GRunArgs &&ins, GRunArgsP &&outs, GCompileArgs &&ar
m_priv->m_lastCompiled(std::move(ins), std::move(outs)); m_priv->m_lastCompiled(std::move(ins), std::move(outs));
} }
void cv::GComputation::apply(const std::vector<cv::gapi::own::Mat> &ins, void cv::GComputation::apply(const std::vector<cv::Mat> &ins,
const std::vector<cv::gapi::own::Mat> &outs, const std::vector<cv::Mat> &outs,
GCompileArgs &&args) GCompileArgs &&args)
{ {
GRunArgs call_ins; GRunArgs call_ins;
GRunArgsP call_outs; GRunArgsP call_outs;
auto tmp = outs; auto tmp = outs;
for (const cv::gapi::own::Mat &m : ins) { call_ins.emplace_back(m); } for (const cv::Mat &m : ins) { call_ins.emplace_back(m); }
for ( cv::gapi::own::Mat &m : tmp) { call_outs.emplace_back(&m); } for ( cv::Mat &m : tmp) { call_outs.emplace_back(&m); }
apply(std::move(call_ins), std::move(call_outs), std::move(args)); apply(std::move(call_ins), std::move(call_outs), std::move(args));
} }

38
modules/gapi/src/api/gmat.cpp
View File

@ -48,10 +48,9 @@ namespace{
} }
} }
#if !defined(GAPI_STANDALONE)
cv::GMatDesc cv::descr_of(const cv::Mat &mat) cv::GMatDesc cv::descr_of(const cv::Mat &mat)
{ {
#if !defined(GAPI_STANDALONE)
const auto mat_dims = mat.size.dims(); const auto mat_dims = mat.size.dims();
if (mat_dims == 2) if (mat_dims == 2)
@ -63,33 +62,39 @@ cv::GMatDesc cv::descr_of(const cv::Mat &mat)
dims[i] = mat.size[i]; dims[i] = mat.size[i];
} }
return GMatDesc{mat.depth(), std::move(dims)}; return GMatDesc{mat.depth(), std::move(dims)};
#else
return (mat.dims.empty())
? GMatDesc{mat.depth(), mat.channels(), {mat.cols, mat.rows}}
: GMatDesc{mat.depth(), mat.dims};
#endif
} }
cv::GMatDesc cv::gapi::own::descr_of(const Mat &mat)
{
return (mat.dims.empty())
? GMatDesc{mat.depth(), mat.channels(), {mat.cols, mat.rows}}
: GMatDesc{mat.depth(), mat.dims};
}
#if !defined(GAPI_STANDALONE)
cv::GMatDesc cv::descr_of(const cv::UMat &mat) cv::GMatDesc cv::descr_of(const cv::UMat &mat)
{ {
GAPI_Assert(mat.size.dims() == 2); GAPI_Assert(mat.size.dims() == 2);
return GMatDesc{ mat.depth(), mat.channels(),{ mat.cols, mat.rows } }; return GMatDesc{ mat.depth(), mat.channels(),{ mat.cols, mat.rows } };
} }
cv::GMetaArgs cv::descrs_of(const std::vector<cv::Mat> &vec)
{
return vec_descr_of(vec);
}
cv::GMetaArgs cv::descrs_of(const std::vector<cv::UMat> &vec) cv::GMetaArgs cv::descrs_of(const std::vector<cv::UMat> &vec)
{ {
return vec_descr_of(vec); return vec_descr_of(vec);
} }
#endif #endif
cv::GMatDesc cv::gapi::own::descr_of(const cv::gapi::own::Mat &mat) cv::GMetaArgs cv::descrs_of(const std::vector<cv::Mat> &vec)
{ {
return (mat.dims.empty()) return vec_descr_of(vec);
? GMatDesc{mat.depth(), mat.channels(), {mat.cols, mat.rows}}
: GMatDesc{mat.depth(), mat.dims};
} }
cv::GMetaArgs cv::gapi::own::descrs_of(const std::vector<cv::gapi::own::Mat> &vec) cv::GMetaArgs cv::gapi::own::descrs_of(const std::vector<Mat> &vec)
{ {
return vec_descr_of(vec); return vec_descr_of(vec);
} }
@ -126,21 +131,14 @@ std::ostream& operator<<(std::ostream& os, const cv::GMatDesc &desc)
namespace { namespace {
template<typename M> inline bool canDescribeHelper(const GMatDesc& desc, const M& mat) template<typename M> inline bool canDescribeHelper(const GMatDesc& desc, const M& mat)
{ {
const auto mat_desc = desc.planar ? descr_of(mat).asPlanar(desc.chan) : descr_of(mat); const auto mat_desc = desc.planar ? cv::descr_of(mat).asPlanar(desc.chan) : cv::descr_of(mat);
return desc == mat_desc; return desc == mat_desc;
} }
} // anonymous namespace } // anonymous namespace
bool GMatDesc::canDescribe(const cv::gapi::own::Mat& mat) const
{
return canDescribeHelper(*this, mat);
}
#if !defined(GAPI_STANDALONE)
bool GMatDesc::canDescribe(const cv::Mat& mat) const bool GMatDesc::canDescribe(const cv::Mat& mat) const
{ {
return canDescribeHelper(*this, mat); return canDescribeHelper(*this, mat);
} }
#endif
}// namespace cv }// namespace cv

48
modules/gapi/src/api/gproto.cpp
View File

@ -103,14 +103,8 @@ cv::GMetaArg cv::descr_of(const cv::GRunArg &arg)
{ {
switch (arg.index()) switch (arg.index())
{ {
#if !defined(GAPI_STANDALONE)
case GRunArg::index_of<cv::Mat>(): case GRunArg::index_of<cv::Mat>():
return cv::GMetaArg(descr_of(util::get<cv::Mat>(arg))); return cv::GMetaArg(cv::descr_of(util::get<cv::Mat>(arg)));
#endif // !defined(GAPI_STANDALONE)
case GRunArg::index_of<cv::gapi::own::Mat>():
return cv::GMetaArg(descr_of(util::get<cv::gapi::own::Mat>(arg)));
case GRunArg::index_of<cv::Scalar>(): case GRunArg::index_of<cv::Scalar>():
return cv::GMetaArg(descr_of(util::get<cv::Scalar>(arg))); return cv::GMetaArg(descr_of(util::get<cv::Scalar>(arg)));
@ -140,10 +134,9 @@ cv::GMetaArg cv::descr_of(const cv::GRunArgP &argp)
switch (argp.index()) switch (argp.index())
{ {
#if !defined(GAPI_STANDALONE) #if !defined(GAPI_STANDALONE)
case GRunArgP::index_of<cv::Mat*>(): return GMetaArg(descr_of(*util::get<cv::Mat*>(argp))); case GRunArgP::index_of<cv::UMat*>(): return GMetaArg(cv::descr_of(*util::get<cv::UMat*>(argp)));
case GRunArgP::index_of<cv::UMat*>(): return GMetaArg(descr_of(*util::get<cv::UMat*>(argp)));
#endif // !defined(GAPI_STANDALONE) #endif // !defined(GAPI_STANDALONE)
case GRunArgP::index_of<cv::gapi::own::Mat*>(): return GMetaArg(descr_of(*util::get<cv::gapi::own::Mat*>(argp))); case GRunArgP::index_of<cv::Mat*>(): return GMetaArg(cv::descr_of(*util::get<cv::Mat*>(argp)));
case GRunArgP::index_of<cv::Scalar*>(): return GMetaArg(descr_of(*util::get<cv::Scalar*>(argp))); case GRunArgP::index_of<cv::Scalar*>(): return GMetaArg(descr_of(*util::get<cv::Scalar*>(argp)));
case GRunArgP::index_of<cv::detail::VectorRef>(): return GMetaArg(util::get<cv::detail::VectorRef>(argp).descr_of()); case GRunArgP::index_of<cv::detail::VectorRef>(): return GMetaArg(util::get<cv::detail::VectorRef>(argp).descr_of());
case GRunArgP::index_of<cv::detail::OpaqueRef>(): return GMetaArg(util::get<cv::detail::OpaqueRef>(argp).descr_of()); case GRunArgP::index_of<cv::detail::OpaqueRef>(): return GMetaArg(util::get<cv::detail::OpaqueRef>(argp).descr_of());
@ -156,13 +149,11 @@ bool cv::can_describe(const GMetaArg& meta, const GRunArgP& argp)
switch (argp.index()) switch (argp.index())
{ {
#if !defined(GAPI_STANDALONE) #if !defined(GAPI_STANDALONE)
case GRunArgP::index_of<cv::UMat*>(): return meta == GMetaArg(cv::descr_of(*util::get<cv::UMat*>(argp)));
#endif // !defined(GAPI_STANDALONE)
case GRunArgP::index_of<cv::Mat*>(): return util::holds_alternative<GMatDesc>(meta) && case GRunArgP::index_of<cv::Mat*>(): return util::holds_alternative<GMatDesc>(meta) &&
util::get<GMatDesc>(meta).canDescribe(*util::get<cv::Mat*>(argp)); util::get<GMatDesc>(meta).canDescribe(*util::get<cv::Mat*>(argp));
case GRunArgP::index_of<cv::UMat*>(): return meta == GMetaArg(descr_of(*util::get<cv::UMat*>(argp))); case GRunArgP::index_of<cv::Scalar*>(): return meta == GMetaArg(cv::descr_of(*util::get<cv::Scalar*>(argp)));
#endif // !defined(GAPI_STANDALONE)
case GRunArgP::index_of<cv::gapi::own::Mat*>(): return util::holds_alternative<GMatDesc>(meta) &&
util::get<GMatDesc>(meta).canDescribe(*util::get<cv::gapi::own::Mat*>(argp));
case GRunArgP::index_of<cv::Scalar*>(): return meta == GMetaArg(descr_of(*util::get<cv::Scalar*>(argp)));
case GRunArgP::index_of<cv::detail::VectorRef>(): return meta == GMetaArg(util::get<cv::detail::VectorRef>(argp).descr_of()); case GRunArgP::index_of<cv::detail::VectorRef>(): return meta == GMetaArg(util::get<cv::detail::VectorRef>(argp).descr_of());
case GRunArgP::index_of<cv::detail::OpaqueRef>(): return meta == GMetaArg(util::get<cv::detail::OpaqueRef>(argp).descr_of()); case GRunArgP::index_of<cv::detail::OpaqueRef>(): return meta == GMetaArg(util::get<cv::detail::OpaqueRef>(argp).descr_of());
default: util::throw_error(std::logic_error("Unsupported GRunArgP type")); default: util::throw_error(std::logic_error("Unsupported GRunArgP type"));
@ -174,12 +165,10 @@ bool cv::can_describe(const GMetaArg& meta, const GRunArg& arg)
switch (arg.index()) switch (arg.index())
{ {
#if !defined(GAPI_STANDALONE) #if !defined(GAPI_STANDALONE)
case GRunArg::index_of<cv::Mat>(): return util::holds_alternative<GMatDesc>(meta) &&
util::get<GMatDesc>(meta).canDescribe(util::get<cv::Mat>(arg));
case GRunArg::index_of<cv::UMat>(): return meta == cv::GMetaArg(descr_of(util::get<cv::UMat>(arg))); case GRunArg::index_of<cv::UMat>(): return meta == cv::GMetaArg(descr_of(util::get<cv::UMat>(arg)));
#endif // !defined(GAPI_STANDALONE) #endif // !defined(GAPI_STANDALONE)
case GRunArg::index_of<cv::gapi::own::Mat>(): return util::holds_alternative<GMatDesc>(meta) && case GRunArg::index_of<cv::Mat>(): return util::holds_alternative<GMatDesc>(meta) &&
util::get<GMatDesc>(meta).canDescribe(util::get<cv::gapi::own::Mat>(arg)); util::get<GMatDesc>(meta).canDescribe(util::get<cv::Mat>(arg));
case GRunArg::index_of<cv::Scalar>(): return meta == cv::GMetaArg(descr_of(util::get<cv::Scalar>(arg))); case GRunArg::index_of<cv::Scalar>(): return meta == cv::GMetaArg(descr_of(util::get<cv::Scalar>(arg)));
case GRunArg::index_of<cv::detail::VectorRef>(): return meta == cv::GMetaArg(util::get<cv::detail::VectorRef>(arg).descr_of()); case GRunArg::index_of<cv::detail::VectorRef>(): return meta == cv::GMetaArg(util::get<cv::detail::VectorRef>(arg).descr_of());
case GRunArg::index_of<cv::detail::OpaqueRef>(): return meta == cv::GMetaArg(util::get<cv::detail::OpaqueRef>(arg).descr_of()); case GRunArg::index_of<cv::detail::OpaqueRef>(): return meta == cv::GMetaArg(util::get<cv::detail::OpaqueRef>(arg).descr_of());
@ -203,21 +192,16 @@ void cv::validate_input_arg(const GRunArg& arg)
switch (arg.index()) switch (arg.index())
{ {
#if !defined(GAPI_STANDALONE) #if !defined(GAPI_STANDALONE)
case GRunArg::index_of<cv::Mat>():
{
const auto desc = descr_of(util::get<cv::Mat>(arg));
GAPI_Assert(desc.size.height != 0 && desc.size.width != 0 && "incorrect dimensions of cv::Mat!"); break;
}
case GRunArg::index_of<cv::UMat>(): case GRunArg::index_of<cv::UMat>():
{ {
const auto desc = descr_of(util::get<cv::UMat>(arg)); const auto desc = cv::descr_of(util::get<cv::UMat>(arg));
GAPI_Assert(desc.size.height != 0 && desc.size.width != 0 && "incorrect dimensions of cv::UMat!"); break; GAPI_Assert(desc.size.height != 0 && desc.size.width != 0 && "incorrect dimensions of cv::UMat!"); break;
} }
#endif // !defined(GAPI_STANDALONE) #endif // !defined(GAPI_STANDALONE)
case GRunArg::index_of<cv::gapi::own::Mat>(): case GRunArg::index_of<cv::Mat>():
{ {
const auto desc = descr_of(util::get<cv::gapi::own::Mat>(arg)); const auto desc = cv::descr_of(util::get<cv::Mat>(arg));
GAPI_Assert(desc.size.height != 0 && desc.size.width != 0 && "incorrect dimensions of own::Mat!"); break; GAPI_Assert(desc.size.height != 0 && desc.size.width != 0 && "incorrect dimensions of Mat!"); break;
} }
default: default:
// No extra handling // No extra handling
@ -271,15 +255,13 @@ const void* cv::gimpl::proto::ptr(const GRunArgP &arg)
switch (arg.index()) switch (arg.index())
{ {
#if !defined(GAPI_STANDALONE) #if !defined(GAPI_STANDALONE)
case GRunArgP::index_of<cv::UMat*>():
return static_cast<const void*>(cv::util::get<cv::UMat*>(arg));
#endif
case GRunArgP::index_of<cv::Mat*>(): case GRunArgP::index_of<cv::Mat*>():
return static_cast<const void*>(cv::util::get<cv::Mat*>(arg)); return static_cast<const void*>(cv::util::get<cv::Mat*>(arg));
case GRunArgP::index_of<cv::Scalar*>(): case GRunArgP::index_of<cv::Scalar*>():
return static_cast<const void*>(cv::util::get<cv::Scalar*>(arg)); return static_cast<const void*>(cv::util::get<cv::Scalar*>(arg));
case GRunArgP::index_of<cv::UMat*>():
return static_cast<const void*>(cv::util::get<cv::UMat*>(arg));
#endif
case GRunArgP::index_of<cv::gapi::own::Mat*>():
return static_cast<const void*>(cv::util::get<cv::gapi::own::Mat*>(arg));
case GRunArgP::index_of<cv::detail::VectorRef>(): case GRunArgP::index_of<cv::detail::VectorRef>():
return cv::util::get<cv::detail::VectorRef>(arg).ptr(); return cv::util::get<cv::detail::VectorRef>(arg).ptr();
case GRunArgP::index_of<cv::detail::OpaqueRef>(): case GRunArgP::index_of<cv::detail::OpaqueRef>():

1
modules/gapi/src/api/gscalar.cpp
View File

@ -8,7 +8,6 @@
#include "precomp.hpp" #include "precomp.hpp"
#include <opencv2/gapi/gscalar.hpp> #include <opencv2/gapi/gscalar.hpp>
#include <opencv2/gapi/own/convert.hpp>
#include "api/gorigin.hpp" #include "api/gorigin.hpp"
// cv::GScalar public implementation /////////////////////////////////////////// // cv::GScalar public implementation ///////////////////////////////////////////

8
modules/gapi/src/backends/common/gbackend.hpp
View File

@ -14,7 +14,6 @@
#include <ade/node.hpp> #include <ade/node.hpp>
#include "opencv2/gapi/garg.hpp" #include "opencv2/gapi/garg.hpp"
#include "opencv2/gapi/own/mat.hpp"
#include "opencv2/gapi/util/optional.hpp" #include "opencv2/gapi/util/optional.hpp"
@ -45,9 +44,9 @@ namespace magazine {
} // namespace magazine } // namespace magazine
#if !defined(GAPI_STANDALONE) #if !defined(GAPI_STANDALONE)
using Mag = magazine::Class<cv::gapi::own::Mat, cv::UMat, cv::Scalar, cv::detail::VectorRef, cv::detail::OpaqueRef>; using Mag = magazine::Class<cv::Mat, cv::UMat, cv::Scalar, cv::detail::VectorRef, cv::detail::OpaqueRef>;
#else #else
using Mag = magazine::Class<cv::gapi::own::Mat, cv::Scalar, cv::detail::VectorRef, cv::detail::OpaqueRef>; using Mag = magazine::Class<cv::Mat, cv::Scalar, cv::detail::VectorRef, cv::detail::OpaqueRef>;
#endif #endif
namespace magazine namespace magazine
@ -98,10 +97,7 @@ inline cv::util::optional<T> getCompileArg(const cv::GCompileArgs &args)
return cv::util::optional<T>(); return cv::util::optional<T>();
} }
void createMat(const cv::GMatDesc& desc, cv::gapi::own::Mat& mat);
#if !defined(GAPI_STANDALONE)
void createMat(const cv::GMatDesc& desc, cv::Mat& mat); void createMat(const cv::GMatDesc& desc, cv::Mat& mat);
#endif
}} // cv::gimpl }} // cv::gimpl

4
modules/gapi/src/backends/cpu/gcpubackend.cpp
View File

@ -96,7 +96,7 @@ cv::gimpl::GCPUExecutable::GCPUExecutable(const ade::Graph &g,
if (desc.storage == Data::Storage::INTERNAL && desc.shape == GShape::GMAT) if (desc.storage == Data::Storage::INTERNAL && desc.shape == GShape::GMAT)
{ {
const auto mat_desc = util::get<cv::GMatDesc>(desc.meta); const auto mat_desc = util::get<cv::GMatDesc>(desc.meta);
auto& mat = m_res.slot<cv::gapi::own::Mat>()[desc.rc]; auto& mat = m_res.slot<cv::Mat>()[desc.rc];
createMat(mat_desc, mat); createMat(mat_desc, mat);
} }
break; break;
@ -128,7 +128,7 @@ cv::GArg cv::gimpl::GCPUExecutable::packArg(const GArg &arg)
const cv::gimpl::RcDesc &ref = arg.get<cv::gimpl::RcDesc>(); const cv::gimpl::RcDesc &ref = arg.get<cv::gimpl::RcDesc>();
switch (ref.shape) switch (ref.shape)
{ {
case GShape::GMAT: return GArg(m_res.slot<cv::gapi::own::Mat>() [ref.id]); case GShape::GMAT: return GArg(m_res.slot<cv::Mat>() [ref.id]);
case GShape::GSCALAR: return GArg(m_res.slot<cv::Scalar>()[ref.id]); case GShape::GSCALAR: return GArg(m_res.slot<cv::Scalar>()[ref.id]);
// Note: .at() is intentional for GArray and GOpaque as objects MUST be already there // Note: .at() is intentional for GArray and GOpaque as objects MUST be already there
// (and constructed by either bindIn/Out or resetInternal) // (and constructed by either bindIn/Out or resetInternal)

8
modules/gapi/src/backends/cpu/gcpukernel.cpp
View File

@ -11,14 +11,14 @@
#include <opencv2/gapi/cpu/gcpukernel.hpp> #include <opencv2/gapi/cpu/gcpukernel.hpp>
const cv::gapi::own::Mat& cv::GCPUContext::inMat(int input) const cv::Mat& cv::GCPUContext::inMat(int input)
{ {
return inArg<cv::gapi::own::Mat>(input); return inArg<cv::Mat>(input);
} }
cv::gapi::own::Mat& cv::GCPUContext::outMatR(int output) cv::Mat& cv::GCPUContext::outMatR(int output)
{ {
return *util::get<cv::gapi::own::Mat*>(m_results.at(output)); return *util::get<cv::Mat*>(m_results.at(output));
} }
const cv::Scalar& cv::GCPUContext::inVal(int input) const cv::Scalar& cv::GCPUContext::inVal(int input)

15
modules/gapi/src/backends/fluid/gfluidbackend.cpp
View File

@ -26,7 +26,6 @@
#include <opencv2/gapi/gcommon.hpp> #include <opencv2/gapi/gcommon.hpp>
#include "logger.hpp" #include "logger.hpp"
#include <opencv2/gapi/own/convert.hpp>
#include <opencv2/gapi/gmat.hpp> //for version of descr_of #include <opencv2/gapi/gmat.hpp> //for version of descr_of
// PRIVATE STUFF! // PRIVATE STUFF!
#include "compiler/gobjref.hpp" #include "compiler/gobjref.hpp"
@ -1246,7 +1245,7 @@ void cv::gimpl::GFluidExecutable::bindInArg(const cv::gimpl::RcDesc &rc, const G
{ {
switch (rc.shape) switch (rc.shape)
{ {
case GShape::GMAT: m_buffers[m_id_map.at(rc.id)].priv().bindTo(util::get<cv::gapi::own::Mat>(arg), true); break; case GShape::GMAT: m_buffers[m_id_map.at(rc.id)].priv().bindTo(util::get<cv::Mat>(arg), true); break;
case GShape::GSCALAR: m_res.slot<cv::Scalar>()[rc.id] = util::get<cv::Scalar>(arg); break; case GShape::GSCALAR: m_res.slot<cv::Scalar>()[rc.id] = util::get<cv::Scalar>(arg); break;
case GShape::GARRAY: m_res.slot<cv::detail::VectorRef>()[rc.id] = util::get<cv::detail::VectorRef>(arg); break; case GShape::GARRAY: m_res.slot<cv::detail::VectorRef>()[rc.id] = util::get<cv::detail::VectorRef>(arg); break;
case GShape::GOPAQUE: m_res.slot<cv::detail::OpaqueRef>()[rc.id] = util::get<cv::detail::OpaqueRef>(arg); break; case GShape::GOPAQUE: m_res.slot<cv::detail::OpaqueRef>()[rc.id] = util::get<cv::detail::OpaqueRef>(arg); break;
@ -1266,20 +1265,12 @@ void cv::gimpl::GFluidExecutable::bindOutArg(const cv::gimpl::RcDesc &rc, const
switch (arg.index()) { switch (arg.index()) {
// FIXME: See the bindInArg comment on Streaming-related changes // FIXME: See the bindInArg comment on Streaming-related changes
case T::index_of<cv::gapi::own::Mat*>(): {
auto &outMat = *util::get<cv::gapi::own::Mat*>(arg);
GAPI_Assert(outMat.data != nullptr);
GAPI_Assert(descr_of(outMat) == desc && "Output argument was not preallocated as it should be ?");
bref.bindTo(outMat, false);
} break;
#if !defined(GAPI_STANDALONE)
case T::index_of<cv::Mat*>(): { case T::index_of<cv::Mat*>(): {
auto &outMat = *util::get<cv::Mat*>(arg); auto &outMat = *util::get<cv::Mat*>(arg);
GAPI_Assert(outMat.data != nullptr); GAPI_Assert(outMat.data != nullptr);
GAPI_Assert(descr_of(outMat) == desc && "Output argument was not preallocated as it should be ?"); GAPI_Assert(cv::descr_of(outMat) == desc && "Output argument was not preallocated as it should be ?");
bref.bindTo(cv::to_own(outMat), false); bref.bindTo(outMat, false);
} break; } break;
#endif // GAPI_STANDALONE
default: GAPI_Assert(false); default: GAPI_Assert(false);
} // switch(arg.index()) } // switch(arg.index())
break; break;

20
modules/gapi/src/backends/fluid/gfluidbuffer.cpp
View File

@ -78,7 +78,7 @@ void fillConstBorderRow(uint8_t* row, int length, int chan, int borderSize, cv::
} }
// Fills const border pixels in the whole mat // Fills const border pixels in the whole mat
void fillBorderConstant(int borderSize, cv::Scalar borderValue, cv::gapi::own::Mat& mat) void fillBorderConstant(int borderSize, cv::Scalar borderValue, cv::Mat& mat)
{ {
// cv::Scalar can contain maximum 4 chan // cv::Scalar can contain maximum 4 chan
GAPI_Assert(mat.channels() > 0 && mat.channels() <= 4); GAPI_Assert(mat.channels() > 0 && mat.channels() <= 4);
@ -178,9 +178,7 @@ const uint8_t* fluid::BorderHandlerT<cv::BORDER_CONSTANT>::inLineB(int /*log_idx
void fluid::BorderHandlerT<cv::BORDER_CONSTANT>::fillCompileTimeBorder(BufferStorageWithBorder& data) void fluid::BorderHandlerT<cv::BORDER_CONSTANT>::fillCompileTimeBorder(BufferStorageWithBorder& data)
{ {
m_const_border.create(1, data.cols(), data.data().type()); m_const_border.create(1, data.cols(), data.data().type());
// FIXME: remove this crutch in deowned Mat m_const_border = m_border_value;
m_const_border = {m_border_value[0], m_border_value[1],
m_border_value[2], m_border_value[3]};
cv::gapi::fillBorderConstant(m_border_size, m_border_value, data.data()); cv::gapi::fillBorderConstant(m_border_size, m_border_value, data.data());
} }
@ -266,7 +264,7 @@ const uint8_t* fluid::BufferStorageWithBorder::inLineB(int log_idx, int desc_hei
} }
} }
static void copyWithoutBorder(const cv::gapi::own::Mat& src, int src_border_size, cv::gapi::own::Mat& dst, int dst_border_size, int startSrcLine, int startDstLine, int lpi) static void copyWithoutBorder(const cv::Mat& src, int src_border_size, cv::Mat& dst, int dst_border_size, int startSrcLine, int startDstLine, int lpi)
{ {
auto subSrc = src(cv::Rect{src_border_size, startSrcLine, src.cols - 2*src_border_size, lpi}); auto subSrc = src(cv::Rect{src_border_size, startSrcLine, src.cols - 2*src_border_size, lpi});
auto subDst = dst(cv::Rect{dst_border_size, startDstLine, dst.cols - 2*dst_border_size, lpi}); auto subDst = dst(cv::Rect{dst_border_size, startDstLine, dst.cols - 2*dst_border_size, lpi});
@ -362,8 +360,8 @@ std::unique_ptr<fluid::BufferStorage> createStorage(int capacity, int desc_width
#endif #endif
} }
std::unique_ptr<BufferStorage> createStorage(const cv::gapi::own::Mat& data, cv::Rect roi); std::unique_ptr<BufferStorage> createStorage(const cv::Mat& data, cv::Rect roi);
std::unique_ptr<BufferStorage> createStorage(const cv::gapi::own::Mat& data, cv::Rect roi) std::unique_ptr<BufferStorage> createStorage(const cv::Mat& data, cv::Rect roi)
{ {
std::unique_ptr<BufferStorageWithoutBorder> storage(new BufferStorageWithoutBorder); std::unique_ptr<BufferStorageWithoutBorder> storage(new BufferStorageWithoutBorder);
storage->attach(data, roi); storage->attach(data, roi);
@ -547,10 +545,10 @@ void fluid::Buffer::Priv::allocate(BorderOpt border,
m_storage->updateOutCache(m_cache, m_write_caret, m_writer_lpi); m_storage->updateOutCache(m_cache, m_write_caret, m_writer_lpi);
} }
void fluid::Buffer::Priv::bindTo(const cv::gapi::own::Mat &data, bool is_input) void fluid::Buffer::Priv::bindTo(const cv::Mat &data, bool is_input)
{ {
// FIXME: move all these fields into a separate structure // FIXME: move all these fields into a separate structure
GAPI_Assert(m_desc == descr_of(data)); GAPI_Assert(m_desc == cv::descr_of(data));
// Currently m_writer_lpi is obtained from metadata which is shared between islands // Currently m_writer_lpi is obtained from metadata which is shared between islands
// and this assert can trigger for slot which connects two fluid islands. // and this assert can trigger for slot which connects two fluid islands.
@ -669,13 +667,13 @@ fluid::Buffer::Buffer(const cv::GMatDesc &desc,
m_priv->allocate(border, border_size, max_line_consumption, skew); m_priv->allocate(border, border_size, max_line_consumption, skew);
} }
fluid::Buffer::Buffer(const cv::gapi::own::Mat &data, bool is_input) fluid::Buffer::Buffer(const cv::Mat &data, bool is_input)
: m_priv(new Priv()) : m_priv(new Priv())
, m_cache(&m_priv->cache()) , m_cache(&m_priv->cache())
{ {
int wlpi = 1, readStart = 0; int wlpi = 1, readStart = 0;
cv::Rect roi{0, 0, data.cols, data.rows}; cv::Rect roi{0, 0, data.cols, data.rows};
m_priv->init(descr_of(data), wlpi, readStart, roi); m_priv->init(cv::descr_of(data), wlpi, readStart, roi);
m_priv->bindTo(data, is_input); m_priv->bindTo(data, is_input);
} }

12
modules/gapi/src/backends/fluid/gfluidbuffer_priv.hpp
View File

@ -53,7 +53,7 @@ template<>
class BorderHandlerT<cv::BORDER_CONSTANT> : public BorderHandler class BorderHandlerT<cv::BORDER_CONSTANT> : public BorderHandler
{ {
cv::Scalar m_border_value; cv::Scalar m_border_value;
cv::gapi::own::Mat m_const_border; cv::Mat m_const_border;
public: public:
BorderHandlerT(int border_size, cv::Scalar border_value); BorderHandlerT(int border_size, cv::Scalar border_value);
@ -65,7 +65,7 @@ public:
class BufferStorage class BufferStorage
{ {
protected: protected:
cv::gapi::own::Mat m_data; cv::Mat m_data;
public: public:
void updateInCache(View::Cache& cache, int start_log_idx, int nLines) const; void updateInCache(View::Cache& cache, int start_log_idx, int nLines) const;
@ -80,8 +80,8 @@ public:
inline bool empty() const { return m_data.empty(); } inline bool empty() const { return m_data.empty(); }
inline const cv::gapi::own::Mat& data() const { return m_data; } inline const cv::Mat& data() const { return m_data; }
inline cv::gapi::own::Mat& data() { return m_data; } inline cv::Mat& data() { return m_data; }
inline int rows() const { return m_data.rows; } inline int rows() const { return m_data.rows; }
inline int cols() const { return m_data.cols; } inline int cols() const { return m_data.cols; }
@ -117,7 +117,7 @@ public:
return m_data.ptr(physIdx(idx), 0); return m_data.ptr(physIdx(idx), 0);
} }
inline void attach(const cv::gapi::own::Mat& _data, cv::Rect _roi) inline void attach(const cv::Mat& _data, cv::Rect _roi)
{ {
m_data = _data(_roi); m_data = _data(_roi);
m_roi = _roi; m_roi = _roi;
@ -263,7 +263,7 @@ public:
cv::Rect roi); cv::Rect roi);
void allocate(BorderOpt border, int border_size, int line_consumption, int skew); void allocate(BorderOpt border, int border_size, int line_consumption, int skew);
void bindTo(const cv::gapi::own::Mat &data, bool is_input); void bindTo(const cv::Mat &data, bool is_input);
inline void addView(const View* view) { m_views.emplace_back(view); } inline void addView(const View* view) { m_views.emplace_back(view); }

12
modules/gapi/src/backends/ie/giebackend.cpp
View File

@ -285,11 +285,11 @@ struct IECallContext
const T& inArg(std::size_t input) { return args.at(input).get<T>(); } const T& inArg(std::size_t input) { return args.at(input).get<T>(); }
// Syntax sugar // Syntax sugar
const cv::gapi::own::Mat& inMat(std::size_t input) { const cv::Mat& inMat(std::size_t input) {
return inArg<cv::gapi::own::Mat>(input); return inArg<cv::Mat>(input);
} }
cv::gapi::own::Mat& outMatR(std::size_t output) { cv::Mat& outMatR(std::size_t output) {
return *cv::util::get<cv::gapi::own::Mat*>(results.at(output)); return *cv::util::get<cv::Mat*>(results.at(output));
} }
template<typename T> std::vector<T>& outVecR(std::size_t output) { // FIXME: the same issue template<typename T> std::vector<T>& outVecR(std::size_t output) { // FIXME: the same issue
@ -391,7 +391,7 @@ cv::GArg cv::gimpl::ie::GIEExecutable::packArg(const cv::GArg &arg) {
const cv::gimpl::RcDesc &ref = arg.get<cv::gimpl::RcDesc>(); const cv::gimpl::RcDesc &ref = arg.get<cv::gimpl::RcDesc>();
switch (ref.shape) switch (ref.shape)
{ {
case GShape::GMAT: return GArg(m_res.slot<cv::gapi::own::Mat>()[ref.id]); case GShape::GMAT: return GArg(m_res.slot<cv::Mat>()[ref.id]);
// Note: .at() is intentional for GArray as object MUST be already there // Note: .at() is intentional for GArray as object MUST be already there
// (and constructed by either bindIn/Out or resetInternal) // (and constructed by either bindIn/Out or resetInternal)
@ -528,7 +528,7 @@ struct Infer: public cv::detail::KernelTag {
// Not a <very> big deal for classifiers and detectors, // Not a <very> big deal for classifiers and detectors,
// but may be critical to segmentation. // but may be critical to segmentation.
cv::gapi::own::Mat& out_mat = ctx.outMatR(i); cv::Mat& out_mat = ctx.outMatR(i);
IE::Blob::Ptr this_blob = iec.this_request.GetBlob(uu.params.output_names[i]); IE::Blob::Ptr this_blob = iec.this_request.GetBlob(uu.params.output_names[i]);
copyFromIE(this_blob, out_mat); copyFromIE(this_blob, out_mat);
} }

2
modules/gapi/src/backends/ocl/goclbackend.cpp
View File

@ -96,7 +96,7 @@ cv::gimpl::GOCLExecutable::GOCLExecutable(const ade::Graph &g,
if (desc.storage == Data::Storage::INTERNAL && desc.shape == GShape::GMAT) if (desc.storage == Data::Storage::INTERNAL && desc.shape == GShape::GMAT)
{ {
const auto mat_desc = util::get<cv::GMatDesc>(desc.meta); const auto mat_desc = util::get<cv::GMatDesc>(desc.meta);
auto& mat = m_res.slot<cv::gapi::own::Mat>()[desc.rc]; auto& mat = m_res.slot<cv::Mat>()[desc.rc];
createMat(mat_desc, mat); createMat(mat_desc, mat);
} }
break; break;

16
modules/gapi/src/backends/plaidml/gplaidmlbackend.cpp
View File

@ -212,20 +212,12 @@ void cv::gimpl::GPlaidMLExecutable::bindInArg(const RcDesc &rc, const GRunArg &
switch (arg.index()) switch (arg.index())
{ {
case GRunArg::index_of<cv::gapi::own::Mat>():
{
auto& arg_mat = util::get<cv::gapi::own::Mat>(arg);
binder_->input(it->second).copy_from(arg_mat.data);
}
break;
#if !defined(GAPI_STANDALONE)
case GRunArg::index_of<cv::Mat>() : case GRunArg::index_of<cv::Mat>() :
{ {
auto& arg_mat = util::get<cv::Mat>(arg); auto& arg_mat = util::get<cv::Mat>(arg);
binder_->input(it->second).copy_from(arg_mat.data); binder_->input(it->second).copy_from(arg_mat.data);
} }
break; break;
#endif // !defined(GAPI_STANDALONE)
default: util::throw_error(std::logic_error("content type of the runtime argument does not match to resource description ?")); default: util::throw_error(std::logic_error("content type of the runtime argument does not match to resource description ?"));
} }
} }
@ -248,20 +240,12 @@ void cv::gimpl::GPlaidMLExecutable::bindOutArg(const RcDesc &rc, const GRunArgP
switch (arg.index()) switch (arg.index())
{ {
case GRunArgP::index_of<cv::gapi::own::Mat*>():
{
auto& arg_mat = *util::get<cv::gapi::own::Mat*>(arg);
binder_->output(it->second).copy_into(arg_mat.data);
}
break;
#if !defined(GAPI_STANDALONE)
case GRunArgP::index_of<cv::Mat*>() : case GRunArgP::index_of<cv::Mat*>() :
{ {
auto& arg_mat = *util::get<cv::Mat*>(arg); auto& arg_mat = *util::get<cv::Mat*>(arg);
binder_->output(it->second).copy_into(arg_mat.data); binder_->output(it->second).copy_into(arg_mat.data);
} }
break; break;
#endif // !defined(GAPI_STANDALONE)
default: util::throw_error(std::logic_error("content type of the runtime argument does not match to resource description ?")); default: util::throw_error(std::logic_error("content type of the runtime argument does not match to resource description ?"));
} }
} }

2
modules/gapi/src/backends/render/grenderocvbackend.cpp
View File

@ -113,7 +113,7 @@ cv::GArg cv::gimpl::render::ocv::GRenderExecutable::packArg(const cv::GArg &arg)
const cv::gimpl::RcDesc &ref = arg.get<cv::gimpl::RcDesc>(); const cv::gimpl::RcDesc &ref = arg.get<cv::gimpl::RcDesc>();
switch (ref.shape) switch (ref.shape)
{ {
case GShape::GMAT: return GArg(m_res.slot<cv::gapi::own::Mat>()[ref.id]); case GShape::GMAT: return GArg(m_res.slot<cv::Mat>()[ref.id]);
case GShape::GARRAY: return GArg(m_res.slot<cv::detail::VectorRef>().at(ref.id)); case GShape::GARRAY: return GArg(m_res.slot<cv::detail::VectorRef>().at(ref.id));
default: default:
util::throw_error(std::logic_error("Unsupported GShape type")); util::throw_error(std::logic_error("Unsupported GShape type"));

2
modules/gapi/src/compiler/gislandmodel.cpp
View File

@ -348,7 +348,7 @@ void GIslandExecutable::run(GIslandExecutable::IInput &in, GIslandExecutable::IO
switch (in_data_orig.index()) switch (in_data_orig.index())
{ {
case cv::GRunArg::index_of<cv::Mat>(): case cv::GRunArg::index_of<cv::Mat>():
in_data = cv::GRunArg{cv::to_own(cv::util::get<cv::Mat>(in_data_orig))}; in_data = cv::GRunArg{cv::util::get<cv::Mat>(in_data_orig)};
break; break;
case cv::GRunArg::index_of<cv::Scalar>(): case cv::GRunArg::index_of<cv::Scalar>():
in_data = cv::GRunArg{(cv::util::get<cv::Scalar>(in_data_orig))}; in_data = cv::GRunArg{(cv::util::get<cv::Scalar>(in_data_orig))};

4
modules/gapi/src/executor/gexecutor.cpp
View File

@ -100,7 +100,7 @@ void cv::gimpl::GExecutor::initResource(const ade::NodeHandle &orig_nh)
case GShape::GMAT: case GShape::GMAT:
{ {
const auto desc = util::get<cv::GMatDesc>(d.meta); const auto desc = util::get<cv::GMatDesc>(d.meta);
auto& mat = m_res.slot<cv::gapi::own::Mat>()[d.rc]; auto& mat = m_res.slot<cv::Mat>()[d.rc];
createMat(desc, mat); createMat(desc, mat);
} }
break; break;
@ -182,7 +182,7 @@ void cv::gimpl::GExecutor::run(cv::gimpl::GRuntimeArgs &&args)
auto check_own_mat = [&desc, &args, &index]() auto check_own_mat = [&desc, &args, &index]()
{ {
auto& out_mat = *get<cv::gapi::own::Mat*>(args.outObjs.at(index)); auto& out_mat = *get<cv::Mat*>(args.outObjs.at(index));
GAPI_Assert(out_mat.data != nullptr && GAPI_Assert(out_mat.data != nullptr &&
desc.canDescribe(out_mat)); desc.canDescribe(out_mat));
}; };

12
modules/gapi/src/executor/gstreamingexecutor.cpp
View File

@ -98,8 +98,6 @@ std::vector<cv::gimpl::stream::Q*> input_queues( ade::Graph &g,
void sync_data(cv::GRunArgs &results, cv::GRunArgsP &outputs) void sync_data(cv::GRunArgs &results, cv::GRunArgsP &outputs)
{ {
namespace own = cv::gapi::own;
for (auto && it : ade::util::zip(ade::util::toRange(outputs), for (auto && it : ade::util::zip(ade::util::toRange(outputs),
ade::util::toRange(results))) ade::util::toRange(results)))
{ {
@ -110,14 +108,9 @@ void sync_data(cv::GRunArgs &results, cv::GRunArgsP &outputs)
using T = cv::GRunArgP; using T = cv::GRunArgP;
switch (out_obj.index()) switch (out_obj.index())
{ {
#if !defined(GAPI_STANDALONE)
case T::index_of<cv::Mat*>(): case T::index_of<cv::Mat*>():
*cv::util::get<cv::Mat*>(out_obj) = std::move(cv::util::get<cv::Mat>(res_obj)); *cv::util::get<cv::Mat*>(out_obj) = std::move(cv::util::get<cv::Mat>(res_obj));
break; break;
#endif // !GAPI_STANDALONE
case T::index_of<own::Mat*>():
*cv::util::get<own::Mat*>(out_obj) = std::move(cv::util::get<own::Mat>(res_obj));
break;
case T::index_of<cv::Scalar*>(): case T::index_of<cv::Scalar*>():
*cv::util::get<cv::Scalar*>(out_obj) = std::move(cv::util::get<cv::Scalar>(res_obj)); *cv::util::get<cv::Scalar*>(out_obj) = std::move(cv::util::get<cv::Scalar>(res_obj));
break; break;
@ -420,13 +413,8 @@ class StreamingOutput final: public cv::gimpl::GIslandExecutable::IOutput
// Prepare this object for posting // Prepare this object for posting
virtual cv::GRunArgP get(int idx) override virtual cv::GRunArgP get(int idx) override
{ {
#if !defined(GAPI_STANDALONE)
using MatType = cv::Mat; using MatType = cv::Mat;
using SclType = cv::Scalar; using SclType = cv::Scalar;
#else
using MatType = cv::gapi::own::Mat;
using SclType = cv::gapi::own::Scalar;
#endif // GAPI_STANDALONE
// Allocate a new posting first, then bind this GRunArgP to this item // Allocate a new posting first, then bind this GRunArgP to this item
auto iter = m_postings[idx].insert(m_postings[idx].end(), Posting{}); auto iter = m_postings[idx].insert(m_postings[idx].end(), Posting{});

8
modules/gapi/test/gapi_async_test.cpp
View File

@ -386,11 +386,8 @@ namespace {
for (auto&& arg : args){ for (auto&& arg : args){
//FIXME: replace this switch with use of visit() on variant, when it will be available //FIXME: replace this switch with use of visit() on variant, when it will be available
switch (arg.index()){ switch (arg.index()){
#if !defined(GAPI_STANDALONE)
case GRunArgP::index_of<cv::Mat*>() : result.emplace_back(*util::get<cv::Mat*>(arg)); break;
case GRunArgP::index_of<cv::UMat*>() : result.emplace_back(*util::get<cv::UMat*>(arg)); break; case GRunArgP::index_of<cv::UMat*>() : result.emplace_back(*util::get<cv::UMat*>(arg)); break;
#endif // !defined(GAPI_STANDALONE) case GRunArgP::index_of<cv::Mat*>() : result.emplace_back(*util::get<cv::Mat*>(arg)); break;
case GRunArgP::index_of<cv::gapi::own::Mat*>() : result.emplace_back(*util::get<cv::gapi::own::Mat*> (arg)); break;
case GRunArgP::index_of<cv::Scalar*>() : result.emplace_back(*util::get<cv::Scalar*> (arg)); break; case GRunArgP::index_of<cv::Scalar*>() : result.emplace_back(*util::get<cv::Scalar*> (arg)); break;
case GRunArgP::index_of<cv::detail::VectorRef>() : result.emplace_back(util::get<cv::detail::VectorRef> (arg)); break; case GRunArgP::index_of<cv::detail::VectorRef>() : result.emplace_back(util::get<cv::detail::VectorRef> (arg)); break;
default : ; default : ;
@ -403,11 +400,8 @@ namespace {
GRunArgsP result; result.reserve(args.size()); GRunArgsP result; result.reserve(args.size());
for (auto&& arg : args){ for (auto&& arg : args){
switch (arg.index()){ switch (arg.index()){
#if !defined(GAPI_STANDALONE)
case GRunArg::index_of<cv::Mat>() : result.emplace_back(&util::get<cv::Mat>(arg)); break; case GRunArg::index_of<cv::Mat>() : result.emplace_back(&util::get<cv::Mat>(arg)); break;
case GRunArg::index_of<cv::UMat>() : result.emplace_back(&util::get<cv::UMat>(arg)); break; case GRunArg::index_of<cv::UMat>() : result.emplace_back(&util::get<cv::UMat>(arg)); break;
#endif // !defined(GAPI_STANDALONE)
case GRunArg::index_of<cv::gapi::own::Mat>() : result.emplace_back(&util::get<cv::gapi::own::Mat> (arg)); break;
case GRunArg::index_of<cv::Scalar>() : result.emplace_back(&util::get<cv::Scalar> (arg)); break; case GRunArg::index_of<cv::Scalar>() : result.emplace_back(&util::get<cv::Scalar> (arg)); break;
case GRunArg::index_of<cv::detail::VectorRef>() : result.emplace_back(util::get<cv::detail::VectorRef> (arg)); break; case GRunArg::index_of<cv::detail::VectorRef>() : result.emplace_back(util::get<cv::detail::VectorRef> (arg)); break;
default : ; default : ;

17
modules/gapi/test/gapi_desc_tests.cpp
View File

@ -137,23 +137,6 @@ TEST(GAPI_MetaDesc, OwnMatDescND)
EXPECT_TRUE(desc.isND()); EXPECT_TRUE(desc.isND());
} }
TEST(GAPI_MetaDesc, CanDescribeOwnMat)
{
constexpr int w = 15;
constexpr int h = 7;
cv::gapi::own::Mat m0(h, w, CV_8UC3, nullptr);
cv::GMatDesc md0{CV_8U,3,{w,h},false};
cv::gapi::own::Mat m1(h*3, w, CV_8UC1, nullptr);
cv::GMatDesc md10{CV_8U,3,{w,h},true};
cv::GMatDesc md11{CV_8U,1,{w,h*3},false};
EXPECT_TRUE (md0 .canDescribe(m0));
EXPECT_FALSE(md0 .canDescribe(m1));
EXPECT_TRUE (md10.canDescribe(m1));
EXPECT_TRUE (md11.canDescribe(m1));
}
TEST(GAPI_MetaDesc, VecOwnMatDesc) TEST(GAPI_MetaDesc, VecOwnMatDesc)
{ {
std::vector<cv::gapi::own::Mat> vec = { std::vector<cv::gapi::own::Mat> vec = {

4
modules/gapi/test/gapi_fluid_test.cpp
View File

@ -50,7 +50,7 @@ TEST(FluidBuffer, InputTest)
const cv::Size buffer_size = {8,8}; const cv::Size buffer_size = {8,8};
cv::Mat in_mat = cv::Mat::eye(buffer_size, CV_8U); cv::Mat in_mat = cv::Mat::eye(buffer_size, CV_8U);
cv::gapi::fluid::Buffer buffer(to_own(in_mat), true); cv::gapi::fluid::Buffer buffer(in_mat, true);
cv::gapi::fluid::View view = buffer.mkView(0, false); cv::gapi::fluid::View view = buffer.mkView(0, false);
view.priv().allocate(1, {}); view.priv().allocate(1, {});
view.priv().reset(1); view.priv().reset(1);
@ -155,7 +155,7 @@ TEST(FluidBuffer, OutputTest)
const cv::Size buffer_size = {8,16}; const cv::Size buffer_size = {8,16};
cv::Mat out_mat = cv::Mat(buffer_size, CV_8U); cv::Mat out_mat = cv::Mat(buffer_size, CV_8U);
cv::gapi::fluid::Buffer buffer(to_own(out_mat), false); cv::gapi::fluid::Buffer buffer(out_mat, false);
int num_writes = 0; int num_writes = 0;
while (num_writes < buffer_size.height) while (num_writes < buffer_size.height)
{ {

15
modules/gapi/test/gapi_sample_pipelines.cpp
View File

@ -327,21 +327,6 @@ TEST(GAPI_Pipeline, PipelineAllocatingKernel)
EXPECT_THROW(comp.apply(in_mat, out_mat, cv::compile_args(pkg)), std::logic_error); EXPECT_THROW(comp.apply(in_mat, out_mat, cv::compile_args(pkg)), std::logic_error);
} }
TEST(GAPI_Pipeline, CanUseOwnMatAsOutput)
{
cv::GMat in;
cv::GComputation comp(in, cv::gapi::bitwise_not(in));
cv::Mat in_mat(3, 3, CV_8UC1);
cv::Mat out_mat(3, 3, CV_8UC1);
cv::gapi::own::Mat in_own_mat(in_mat.rows, in_mat.cols, CV_8UC1, in_mat.data);
cv::gapi::own::Mat out_own_mat(out_mat.rows, out_mat.cols, CV_8UC1, out_mat.data);
// FIXME add overload for apply(cv::gapi::own::Mat in, cv::gapi::own::Mat& out)
EXPECT_NO_THROW(comp.apply({in_own_mat}, {out_own_mat}));
}
TEST(GAPI_Pipeline, CreateKernelImplFromLambda) TEST(GAPI_Pipeline, CreateKernelImplFromLambda)
{ {
cv::Size size(300, 300); cv::Size size(300, 300);

1
modules/gapi/test/own/mat_tests.cpp
View File

@ -7,6 +7,7 @@
#include "../test_precomp.hpp" #include "../test_precomp.hpp"
#include <opencv2/gapi/own/mat.hpp> #include <opencv2/gapi/own/mat.hpp>
#include <opencv2/gapi/own/convert.hpp>
#include <opencv2/gapi/util/compiler_hints.hpp> //suppress_unused_warning #include <opencv2/gapi/util/compiler_hints.hpp> //suppress_unused_warning
namespace opencv_test namespace opencv_test