Merge pull request #16805 from Volskig:mp/ocv-gapi-standalone-scalar

G-API: Unification of own:: Scalar with cv:: Scalar

* cvdefs.hpp

* Small changes

* Deowned Scalar. Does't work

* Something

* Removed to_ocv for Scalar

* Clear code

* Deleted whitespaces

* Added include<..own/scalar.hpp in cvdefs.hpp.

* Long string split on two now

* Comment about scalar

* Comment about crutch

* Removed second varible in scalar_wrapper

* Changed wrapper for scalar, alignment

* Alignment

* Whitespaces

* Removed scalar_wrapper

modules/gapi/include/opencv2/gapi/cpu/gcpukernel.hpp

@@ -99,8 +99,8 @@ public:
     const cv::gapi::own::Mat&   inMat(int input);
     cv::gapi::own::Mat&         outMatR(int output); // FIXME: Avoid cv::gapi::own::Mat m = ctx.outMatR()
 
-    const cv::gapi::own::Scalar& inVal(int input);
-    cv::gapi::own::Scalar& outValR(int output); // FIXME: Avoid cv::gapi::own::Scalar s = ctx.outValR()
+    const cv::Scalar& inVal(int input);
+    cv::Scalar& outValR(int output); // FIXME: Avoid cv::Scalar s = ctx.outValR()
     template<typename T> std::vector<T>& outVecR(int output) // FIXME: the same issue
     {
         return outVecRef(output).wref<T>();
@@ -155,7 +155,7 @@ template<> struct get_in<cv::GMatP>
 };
 template<> struct get_in<cv::GScalar>
 {
-    static cv::Scalar get(GCPUContext &ctx, int idx) { return to_ocv(ctx.inVal(idx)); }
+    static cv::Scalar get(GCPUContext &ctx, int idx) { return ctx.inVal(idx); }
 };
 template<typename U> struct get_in<cv::GArray<U> >
 {
@@ -208,23 +208,12 @@ struct tracked_cv_mat{
     }
 };
 
-struct scalar_wrapper
-{
-    scalar_wrapper(cv::gapi::own::Scalar& s) : m_s{cv::gapi::own::to_ocv(s)}, m_org_s(s) {};
-    operator cv::Scalar& () { return m_s; }
-    void writeBack() const  { m_org_s = to_own(m_s); }
-
-    cv::Scalar m_s;
-    cv::gapi::own::Scalar& m_org_s;
-};
-
 template<typename... Outputs>
 void postprocess(Outputs&... outs)
 {
     struct
     {
         void operator()(tracked_cv_mat* bm) { bm->validate();  }
-        void operator()(scalar_wrapper* sw) { sw->writeBack(); }
         void operator()(...)                {                  }
 
     } validate;
@@ -251,10 +240,9 @@ template<> struct get_out<cv::GMatP>
 };
 template<> struct get_out<cv::GScalar>
 {
-    static scalar_wrapper get(GCPUContext &ctx, int idx)
+    static cv::Scalar& get(GCPUContext &ctx, int idx)
     {
-        auto& s = ctx.outValR(idx);
-        return {s};
+        return ctx.outValR(idx);
     }
 };
 template<typename U> struct get_out<cv::GArray<U>>

modules/gapi/include/opencv2/gapi/fluid/gfluidbuffer.hpp

@@ -18,7 +18,6 @@
 #include <opencv2/gapi/gmat.hpp>
 
 #include <opencv2/gapi/util/optional.hpp>
-#include <opencv2/gapi/own/scalar.hpp>
 #include <opencv2/gapi/own/mat.hpp>
 
 namespace cv {
@@ -27,13 +26,11 @@ namespace fluid {
 
 struct Border
 {
-#if !defined(GAPI_STANDALONE)
     // This constructor is required to support existing kernels which are part of G-API
-    Border(int _type, cv::Scalar _val) : type(_type), value(to_own(_val)) {};
-#endif // !defined(GAPI_STANDALONE)
-    Border(int _type, cv::gapi::own::Scalar _val) : type(_type), value(_val) {};
+    Border(int _type, cv::Scalar _val) : type(_type), value(_val) {};
+
     int type;
-    cv::gapi::own::Scalar value;
+    cv::Scalar value;
 };
 
 using BorderOpt = util::optional<Border>;

modules/gapi/include/opencv2/gapi/fluid/gfluidkernel.hpp

@@ -179,17 +179,10 @@ template<> struct fluid_get_in<cv::GMat>
 template<> struct fluid_get_in<cv::GScalar>
 {
     // FIXME: change to return by reference when moved to own::Scalar
-#if !defined(GAPI_STANDALONE)
     static const cv::Scalar get(const cv::GArgs &in_args, int idx)
     {
-        return cv::gapi::own::to_ocv(in_args[idx].unsafe_get<cv::gapi::own::Scalar>());
+        return in_args[idx].unsafe_get<cv::Scalar>();
     }
-#else
-    static const cv::gapi::own::Scalar get(const cv::GArgs &in_args, int idx)
-    {
-        return in_args[idx].get<cv::gapi::own::Scalar>();
-    }
-#endif // !defined(GAPI_STANDALONE)
 };
 
 template<typename U> struct fluid_get_in<cv::GArray<U>>

modules/gapi/include/opencv2/gapi/garg.hpp

@@ -23,7 +23,6 @@
 #include <opencv2/gapi/gopaque.hpp>
 #include <opencv2/gapi/gtype_traits.hpp>
 #include <opencv2/gapi/gmetaarg.hpp>
-#include <opencv2/gapi/own/scalar.hpp>
 #include <opencv2/gapi/streaming/source.hpp>
 
 namespace cv {
@@ -91,12 +90,11 @@ using GArgs = std::vector<GArg>;
 using GRunArg  = util::variant<
 #if !defined(GAPI_STANDALONE)
     cv::Mat,
-    cv::Scalar,
     cv::UMat,
 #endif // !defined(GAPI_STANDALONE)
     cv::gapi::wip::IStreamSource::Ptr,
     cv::gapi::own::Mat,
-    cv::gapi::own::Scalar,
+    cv::Scalar,
     cv::detail::VectorRef,
     cv::detail::OpaqueRef
     >;
@@ -125,11 +123,10 @@ struct Data: public GRunArg
 using GRunArgP = util::variant<
 #if !defined(GAPI_STANDALONE)
     cv::Mat*,
-    cv::Scalar*,
     cv::UMat*,
 #endif // !defined(GAPI_STANDALONE)
     cv::gapi::own::Mat*,
-    cv::gapi::own::Scalar*,
+    cv::Scalar*,
     cv::detail::VectorRef,
     cv::detail::OpaqueRef
     >;

modules/gapi/include/opencv2/gapi/gscalar.hpp

@@ -14,7 +14,6 @@
 #include <opencv2/gapi/opencv_includes.hpp>
 #include <opencv2/gapi/gcommon.hpp> // GShape
 #include <opencv2/gapi/util/optional.hpp>
-#include <opencv2/gapi/own/scalar.hpp>
 
 namespace cv
 {
@@ -31,11 +30,9 @@ class GAPI_EXPORTS GScalar
 {
 public:
     GScalar();                                         // Empty constructor
-    explicit GScalar(const cv::gapi::own::Scalar& s);  // Constant value constructor from cv::gapi::own::Scalar
-    explicit GScalar(cv::gapi::own::Scalar&& s);       // Constant value move-constructor from cv::gapi::own::Scalar
-#if !defined(GAPI_STANDALONE)
     explicit GScalar(const cv::Scalar& s);  // Constant value constructor from cv::Scalar
-#endif  // !defined(GAPI_STANDALONE)
+    explicit GScalar(cv::Scalar&& s);       // Constant value move-constructor from cv::Scalar
+
     GScalar(double v0);                                // Constant value constructor from double
     GScalar(const GNode &n, std::size_t out);          // Operation result constructor
 
@@ -69,12 +66,7 @@ struct GScalarDesc
 
 static inline GScalarDesc empty_scalar_desc() { return GScalarDesc(); }
 
-#if !defined(GAPI_STANDALONE)
 GAPI_EXPORTS GScalarDesc descr_of(const cv::Scalar            &scalar);
-#endif // !defined(GAPI_STANDALONE)
-/** @} */
-
-GAPI_EXPORTS GScalarDesc descr_of(const cv::gapi::own::Scalar &scalar);
 
 std::ostream& operator<<(std::ostream& os, const cv::GScalarDesc &desc);
 

modules/gapi/include/opencv2/gapi/gtype_traits.hpp

@@ -107,10 +107,9 @@ namespace detail
 #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::Scalar>            { using type = cv::GScalar;   };
 #endif // !defined(GAPI_STANDALONE)
     template<>           struct GTypeOf<cv::gapi::own::Mat>    { using type = cv::GMat;      };
-    template<>           struct GTypeOf<cv::gapi::own::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                        { using type = cv::GOpaque<U>;};
     // FIXME: This is not quite correct since IStreamSource may produce not only Mat but also Scalar

modules/gapi/include/opencv2/gapi/ocl/goclkernel.hpp

@@ -62,8 +62,8 @@ public:
     const cv::UMat&  inMat(int input);
     cv::UMat&  outMatR(int output); // FIXME: Avoid cv::Mat m = ctx.outMatR()
 
-    const cv::gapi::own::Scalar& inVal(int input);
-    cv::gapi::own::Scalar& outValR(int output); // FIXME: Avoid cv::gapi::own::Scalar s = ctx.outValR()
+    const cv::Scalar& inVal(int input);
+    cv::Scalar& outValR(int output); // FIXME: Avoid cv::Scalar s = ctx.outValR()
     template<typename T> std::vector<T>& outVecR(int output) // FIXME: the same issue
     {
         return outVecRef(output).wref<T>();
@@ -110,7 +110,7 @@ template<> struct ocl_get_in<cv::GMat>
 };
 template<> struct ocl_get_in<cv::GScalar>
 {
-    static cv::Scalar get(GOCLContext &ctx, int idx) { return to_ocv(ctx.inVal(idx)); }
+    static cv::Scalar get(GOCLContext &ctx, int idx) { return ctx.inVal(idx); }
 };
 template<typename U> struct ocl_get_in<cv::GArray<U> >
 {
@@ -146,24 +146,12 @@ struct tracked_cv_umat{
     }
 };
 
-struct scalar_wrapper_ocl
-{
-    //FIXME reuse CPU (OpenCV) plugin code
-    scalar_wrapper_ocl(cv::gapi::own::Scalar& s) : m_s{cv::gapi::own::to_ocv(s)}, m_org_s(s) {};
-    operator cv::Scalar& () { return m_s; }
-    void writeBack() const  { m_org_s = to_own(m_s); }
-
-    cv::Scalar m_s;
-    cv::gapi::own::Scalar& m_org_s;
-};
-
 template<typename... Outputs>
 void postprocess_ocl(Outputs&... outs)
 {
     struct
     {
         void operator()(tracked_cv_umat* bm) { bm->validate(); }
-        void operator()(scalar_wrapper_ocl* sw) { sw->writeBack(); }
         void operator()(...) {                  }
 
     } validate;
@@ -183,10 +171,9 @@ template<> struct ocl_get_out<cv::GMat>
 };
 template<> struct ocl_get_out<cv::GScalar>
 {
-    static scalar_wrapper_ocl get(GOCLContext &ctx, int idx)
+    static cv::Scalar& get(GOCLContext &ctx, int idx)
     {
-        auto& s = ctx.outValR(idx);
-        return{ s };
+        return ctx.outValR(idx);
     }
 };
 template<typename U> struct ocl_get_out<cv::GArray<U> >

modules/gapi/include/opencv2/gapi/own/convert.hpp

@@ -13,7 +13,6 @@
 #include <opencv2/gapi/opencv_includes.hpp>
 #include <opencv2/gapi/own/types.hpp>
 #include <opencv2/gapi/own/mat.hpp>
-#include <opencv2/gapi/own/scalar.hpp>
 
 namespace cv
 {
@@ -35,9 +34,6 @@ namespace cv
             :  cv::gapi::own::Mat{to_own<int>(m.size), m.type(), m.data};
     };
 
-
-    inline cv::gapi::own::Scalar to_own(const cv::Scalar& s) { return {s[0], s[1], s[2], s[3]}; };
-
     inline cv::gapi::own::Size to_own (const Size& s) { return {s.width, s.height}; };
 
     inline cv::gapi::own::Rect to_own (const Rect& r) { return {r.x, r.y, r.width, r.height}; };
@@ -53,9 +49,6 @@ namespace own
             : cv::Mat{m.dims, m.type(), m.data};
     }
            cv::Mat to_ocv(Mat&&)    = delete;
-
-    inline cv::Scalar to_ocv(const Scalar& s) { return {s[0], s[1], s[2], s[3]}; };
-
     inline cv::Size to_ocv (const Size& s) { return cv::Size(s.width, s.height); };
 
     inline cv::Rect to_ocv (const Rect& r) { return cv::Rect(r.x, r.y, r.width, r.height); };

modules/gapi/include/opencv2/gapi/own/cvdefs.hpp

@@ -9,6 +9,7 @@
 #define OPENCV_GAPI_CV_DEFS_HPP
 
 #if defined(GAPI_STANDALONE)
+#include <opencv2/gapi/own/scalar.hpp> // cv::gapi::own::Scalar
 
 // Simulate OpenCV definitions taken from various
 // OpenCV interface headers if G-API is built in a
@@ -137,6 +138,8 @@ enum InterpolationFlags{
     INTER_LINEAR_EXACT   = 5,
     INTER_MAX            = 7,
 };
+// replacement of cv's structures:
+using Scalar = gapi::own::Scalar;
 } // namespace cv
 
 static inline int cvFloor( double value )

modules/gapi/include/opencv2/gapi/render/render.hpp

@@ -17,7 +17,6 @@
 #include <opencv2/gapi/opencv_includes.hpp>
 #include <opencv2/gapi/util/variant.hpp>
 #include <opencv2/gapi/own/exports.hpp>
-#include <opencv2/gapi/own/scalar.hpp>
 
 
 /** \defgroup gapi_draw G-API Drawing and composition functionality

modules/gapi/src/api/gbackend.cpp

@@ -152,13 +152,10 @@ void bindInArg(Mag& mag, const RcDesc &rc, const GRunArg &arg, bool is_umat)
 
     case GShape::GSCALAR:
     {
-        auto& mag_scalar = mag.template slot<cv::gapi::own::Scalar>()[rc.id];
+        auto& mag_scalar = mag.template slot<cv::Scalar>()[rc.id];
         switch (arg.index())
         {
-            case GRunArg::index_of<cv::gapi::own::Scalar>() : mag_scalar = util::get<cv::gapi::own::Scalar>(arg); break;
-#if !defined(GAPI_STANDALONE)
-            case GRunArg::index_of<cv::Scalar>()            : mag_scalar = to_own(util::get<cv::Scalar>(arg));    break;
-#endif //  !defined(GAPI_STANDALONE)
+        case GRunArg::index_of<cv::Scalar>() : mag_scalar = util::get<cv::Scalar>(arg);    break;
         default: util::throw_error(std::logic_error("content type of the runtime argument does not match to resource description ?"));
         }
         break;
@@ -222,13 +219,10 @@ void bindOutArg(Mag& mag, const RcDesc &rc, const GRunArgP &arg, bool is_umat)
 
     case GShape::GSCALAR:
     {
-        auto& mag_scalar = mag.template slot<cv::gapi::own::Scalar>()[rc.id];
+        auto& mag_scalar = mag.template slot<cv::Scalar>()[rc.id];
         switch (arg.index())
         {
-            case GRunArgP::index_of<cv::gapi::own::Scalar*>() : mag_scalar = *util::get<cv::gapi::own::Scalar*>(arg); break;
-#if !defined(GAPI_STANDALONE)
-            case GRunArgP::index_of<cv::Scalar*>()            : mag_scalar = to_own(*util::get<cv::Scalar*>(arg)); break;
-#endif //  !defined(GAPI_STANDALONE)
+        case GRunArgP::index_of<cv::Scalar*>() : mag_scalar = *util::get<cv::Scalar*>(arg); break;
         default: util::throw_error(std::logic_error("content type of the runtime argument does not match to resource description ?"));
         }
         break;
@@ -265,7 +259,7 @@ void resetInternalData(Mag& mag, const Data &d)
         break;
 
     case GShape::GSCALAR:
-        mag.template slot<cv::gapi::own::Scalar>()[d.rc] = cv::gapi::own::Scalar();
+        mag.template slot<cv::Scalar>()[d.rc] = cv::Scalar();
         break;
 
     case GShape::GMAT:
@@ -284,7 +278,7 @@ cv::GRunArg getArg(const Mag& mag, const RcDesc &ref)
     switch (ref.shape)
     {
     case GShape::GMAT:    return GRunArg(mag.template slot<cv::gapi::own::Mat>().at(ref.id));
-    case GShape::GSCALAR: return GRunArg(mag.template slot<cv::gapi::own::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
     //   (and constructed by either bindIn/Out or resetInternal)
     case GShape::GARRAY:  return GRunArg(mag.template slot<cv::detail::VectorRef>().at(ref.id));
@@ -310,7 +304,7 @@ cv::GRunArgP getObjPtr(Mag& mag, const RcDesc &rc, bool is_umat)
         }
         else
             return GRunArgP(&mag.template slot<cv::gapi::own::Mat>()[rc.id]);
-    case GShape::GSCALAR: return GRunArgP(&mag.template slot<cv::gapi::own::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
     //   (and constructor by either bindIn/Out or resetInternal)
     case GShape::GARRAY:
@@ -381,10 +375,7 @@ void writeBack(const Mag& mag, const RcDesc &rc, GRunArgP &g_arg, bool is_umat)
     {
         switch (g_arg.index())
         {
-            case GRunArgP::index_of<cv::gapi::own::Scalar*>() : *util::get<cv::gapi::own::Scalar*>(g_arg) = mag.template slot<cv::gapi::own::Scalar>().at(rc.id); break;
-#if !defined(GAPI_STANDALONE)
-            case GRunArgP::index_of<cv::Scalar*>()            : *util::get<cv::Scalar*>(g_arg) = cv::gapi::own::to_ocv(mag.template slot<cv::gapi::own::Scalar>().at(rc.id)); break;
-#endif //  !defined(GAPI_STANDALONE)
+        case GRunArgP::index_of<cv::Scalar*>() : *util::get<cv::Scalar*>(g_arg) = mag.template slot<cv::Scalar>().at(rc.id); break;
         default: util::throw_error(std::logic_error("content type of the runtime argument does not match to resource description ?"));
         }
         break;

modules/gapi/src/api/gproto.cpp

@@ -74,7 +74,7 @@ cv::GRunArg cv::value_of(const cv::GOrigin &origin)
 {
     switch (origin.shape)
     {
-    case GShape::GSCALAR: return GRunArg(util::get<cv::gapi::own::Scalar>(origin.value));
+    case GShape::GSCALAR: return GRunArg(util::get<cv::Scalar>(origin.value));
     default: util::throw_error(std::logic_error("Unsupported shape for constant"));
     }
 }
@@ -102,15 +102,13 @@ cv::GMetaArg cv::descr_of(const cv::GRunArg &arg)
         case GRunArg::index_of<cv::Mat>():
             return cv::GMetaArg(descr_of(util::get<cv::Mat>(arg)));
 
-        case GRunArg::index_of<cv::Scalar>():
-            return cv::GMetaArg(descr_of(util::get<cv::Scalar>(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::gapi::own::Scalar>():
-            return cv::GMetaArg(descr_of(util::get<cv::gapi::own::Scalar>(arg)));
+        case GRunArg::index_of<cv::Scalar>():
+            return cv::GMetaArg(descr_of(util::get<cv::Scalar>(arg)));
 
         case GRunArg::index_of<cv::detail::VectorRef>():
             return cv::GMetaArg(util::get<cv::detail::VectorRef>(arg).descr_of());
@@ -139,10 +137,9 @@ cv::GMetaArg cv::descr_of(const cv::GRunArgP &argp)
 #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(descr_of(*util::get<cv::UMat*>(argp)));
-    case GRunArgP::index_of<cv::Scalar*>():            return GMetaArg(descr_of(*util::get<cv::Scalar*>(argp)));
 #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::gapi::own::Scalar*>(): return GMetaArg(descr_of(*util::get<cv::gapi::own::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::OpaqueRef>():  return GMetaArg(util::get<cv::detail::OpaqueRef>(argp).descr_of());
     default: util::throw_error(std::logic_error("Unsupported GRunArgP type"));
@@ -157,11 +154,10 @@ bool cv::can_describe(const GMetaArg& meta, const GRunArgP& argp)
     case GRunArgP::index_of<cv::Mat*>():               return util::holds_alternative<GMatDesc>(meta) &&
                                                               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(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::gapi::own::Scalar*>(): return meta == GMetaArg(descr_of(*util::get<cv::gapi::own::Scalar*>(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::OpaqueRef>():  return meta == GMetaArg(util::get<cv::detail::OpaqueRef>(argp).descr_of());
     default: util::throw_error(std::logic_error("Unsupported GRunArgP type"));
@@ -176,11 +172,10 @@ bool cv::can_describe(const GMetaArg& meta, const GRunArg& arg)
     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::Scalar>():            return meta == cv::GMetaArg(descr_of(util::get<cv::Scalar>(arg)));
 #endif //  !defined(GAPI_STANDALONE)
     case GRunArg::index_of<cv::gapi::own::Mat>():    return util::holds_alternative<GMatDesc>(meta) &&
                                                             util::get<GMatDesc>(meta).canDescribe(util::get<cv::gapi::own::Mat>(arg));
-    case GRunArg::index_of<cv::gapi::own::Scalar>(): return meta == cv::GMetaArg(descr_of(util::get<cv::gapi::own::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::OpaqueRef>(): return meta == cv::GMetaArg(util::get<cv::detail::OpaqueRef>(arg).descr_of());
     case GRunArg::index_of<cv::gapi::wip::IStreamSource::Ptr>(): return util::holds_alternative<GMatDesc>(meta); // FIXME(?) may be not the best option

modules/gapi/src/api/gscalar.cpp

@@ -22,18 +22,18 @@ cv::GScalar::GScalar(const GNode &n, std::size_t out)
 {
 }
 
-cv::GScalar::GScalar(const cv::gapi::own::Scalar& s)
+cv::GScalar::GScalar(const cv::Scalar& s)
     : m_priv(new GOrigin(GShape::GSCALAR, cv::gimpl::ConstVal(s)))
 {
 }
 
-cv::GScalar::GScalar(cv::gapi::own::Scalar&& s)
+cv::GScalar::GScalar(cv::Scalar&& s)
     : m_priv(new GOrigin(GShape::GSCALAR, cv::gimpl::ConstVal(std::move(s))))
 {
 }
 
 cv::GScalar::GScalar(double v0)
-    : m_priv(new GOrigin(GShape::GSCALAR, cv::gimpl::ConstVal(cv::gapi::own::Scalar(v0))))
+    : m_priv(new GOrigin(GShape::GSCALAR, cv::gimpl::ConstVal(cv::Scalar(v0))))
 {
 }
 
@@ -47,23 +47,11 @@ const cv::GOrigin& cv::GScalar::priv() const
     return *m_priv;
 }
 
-cv::GScalarDesc cv::descr_of(const cv::gapi::own::Scalar &)
+cv::GScalarDesc cv::descr_of(const cv::Scalar &)
 {
     return empty_scalar_desc();
 }
 
-#if !defined(GAPI_STANDALONE)
-cv::GScalar::GScalar(const cv::Scalar& s)
-    : m_priv(new GOrigin(GShape::GSCALAR, cv::gimpl::ConstVal(to_own(s))))
-{
-}
-
-cv::GScalarDesc cv::descr_of(const cv::Scalar& s)
-{
-    return cv::descr_of(to_own(s));
-}
-#endif // !defined(GAPI_STANDALONE)
-
 namespace cv {
 std::ostream& operator<<(std::ostream& os, const cv::GScalarDesc &)
 {

modules/gapi/src/backends/common/gbackend.hpp

@@ -17,7 +17,6 @@
 #include "opencv2/gapi/own/mat.hpp"
 
 #include "opencv2/gapi/util/optional.hpp"
-#include "opencv2/gapi/own/scalar.hpp"
 
 #include "compiler/gmodel.hpp"
 
@@ -46,9 +45,9 @@ namespace magazine {
 
 } // namespace magazine
 #if !defined(GAPI_STANDALONE)
-using Mag = magazine::Class<cv::gapi::own::Mat, cv::UMat, cv::gapi::own::Scalar, cv::detail::VectorRef, cv::detail::OpaqueRef>;
+using Mag = magazine::Class<cv::gapi::own::Mat, cv::UMat, cv::Scalar, cv::detail::VectorRef, cv::detail::OpaqueRef>;
 #else
-using Mag = magazine::Class<cv::gapi::own::Mat, cv::gapi::own::Scalar, cv::detail::VectorRef, cv::detail::OpaqueRef>;
+using Mag = magazine::Class<cv::gapi::own::Mat, cv::Scalar, cv::detail::VectorRef, cv::detail::OpaqueRef>;
 #endif
 
 namespace magazine

modules/gapi/src/backends/cpu/gcpubackend.cpp

@@ -129,7 +129,7 @@ cv::GArg cv::gimpl::GCPUExecutable::packArg(const GArg &arg)
     switch (ref.shape)
     {
     case GShape::GMAT:    return GArg(m_res.slot<cv::gapi::own::Mat>()   [ref.id]);
-    case GShape::GSCALAR: return GArg(m_res.slot<cv::gapi::own::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
     //   (and constructed by either bindIn/Out or resetInternal)
     case GShape::GARRAY:  return GArg(m_res.slot<cv::detail::VectorRef>().at(ref.id));

modules/gapi/src/backends/cpu/gcpukernel.cpp

@@ -21,14 +21,14 @@ cv::gapi::own::Mat&  cv::GCPUContext::outMatR(int output)
     return *util::get<cv::gapi::own::Mat*>(m_results.at(output));
 }
 
-const cv::gapi::own::Scalar& cv::GCPUContext::inVal(int input)
+const cv::Scalar& cv::GCPUContext::inVal(int input)
 {
-    return inArg<cv::gapi::own::Scalar>(input);
+    return inArg<cv::Scalar>(input);
 }
 
-cv::gapi::own::Scalar& cv::GCPUContext::outValR(int output)
+cv::Scalar& cv::GCPUContext::outValR(int output)
 {
-    return *util::get<cv::gapi::own::Scalar*>(m_results.at(output));
+    return *util::get<cv::Scalar*>(m_results.at(output));
 }
 
 cv::detail::VectorRef& cv::GCPUContext::outVecRef(int output)

modules/gapi/src/backends/fluid/gfluidbackend.cpp

@@ -1248,7 +1248,7 @@ void cv::gimpl::GFluidExecutable::bindInArg(const cv::gimpl::RcDesc &rc, const G
     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::GSCALAR: m_res.slot<cv::gapi::own::Scalar>()[rc.id] = util::get<cv::gapi::own::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::GOPAQUE: m_res.slot<cv::detail::OpaqueRef>()[rc.id] = util::get<cv::detail::OpaqueRef>(arg); break;
     }
@@ -1301,7 +1301,7 @@ void cv::gimpl::GFluidExecutable::packArg(cv::GArg &in_arg, const cv::GArg &op_a
         const cv::gimpl::RcDesc &ref = op_arg.get<cv::gimpl::RcDesc>();
         if (ref.shape == GShape::GSCALAR)
         {
-            in_arg = GArg(m_res.slot<cv::gapi::own::Scalar>()[ref.id]);
+            in_arg = GArg(m_res.slot<cv::Scalar>()[ref.id]);
         }
         else if (ref.shape == GShape::GARRAY)
         {

modules/gapi/src/backends/fluid/gfluidbackend.hpp

@@ -129,7 +129,7 @@ class GFluidExecutable final: public GIslandExecutable
 
     std::vector<FluidAgent*> m_script;
 
-    using Magazine = detail::magazine<cv::gapi::own::Scalar, cv::detail::VectorRef, cv::detail::OpaqueRef>;
+    using Magazine = detail::magazine<cv::Scalar, cv::detail::VectorRef, cv::detail::OpaqueRef>;
     Magazine m_res;
 
     std::size_t m_num_int_buffers; // internal buffers counter (m_buffers - num_scratch)

modules/gapi/src/backends/fluid/gfluidbuffer.cpp

@@ -64,7 +64,7 @@ void fillBorderReflectRow(uint8_t* row, int length, int chan, int borderSize)
 }
 
 template<typename T>
-void fillConstBorderRow(uint8_t* row, int length, int chan, int borderSize, cv::gapi::own::Scalar borderValue)
+void fillConstBorderRow(uint8_t* row, int length, int chan, int borderSize, cv::Scalar borderValue)
 {
     GAPI_DbgAssert(chan > 0 && chan <= 4);
 
@@ -81,7 +81,7 @@ void fillConstBorderRow(uint8_t* row, int length, int chan, int borderSize, cv::
 }
 
 // Fills const border pixels in the whole mat
-void fillBorderConstant(int borderSize, cv::gapi::own::Scalar borderValue, cv::gapi::own::Mat& mat)
+void fillBorderConstant(int borderSize, cv::Scalar borderValue, cv::gapi::own::Mat& mat)
 {
     // cv::Scalar can contain maximum 4 chan
     GAPI_Assert(mat.channels() > 0 && mat.channels() <= 4);
@@ -169,7 +169,7 @@ const uint8_t* fluid::BorderHandlerT<BorderType>::inLineB(int log_idx, const Buf
     return data.ptr(idx);
 }
 
-fluid::BorderHandlerT<cv::BORDER_CONSTANT>::BorderHandlerT(int border_size, cv::gapi::own::Scalar border_value)
+fluid::BorderHandlerT<cv::BORDER_CONSTANT>::BorderHandlerT(int border_size, cv::Scalar border_value)
     : BorderHandler(border_size), m_border_value(border_value)
 { /* nothing */ }
 
@@ -181,7 +181,9 @@ const uint8_t* fluid::BorderHandlerT<cv::BORDER_CONSTANT>::inLineB(int /*log_idx
 void fluid::BorderHandlerT<cv::BORDER_CONSTANT>::fillCompileTimeBorder(BufferStorageWithBorder& data)
 {
     m_const_border.create(1, data.cols(), data.data().type());
-    m_const_border = m_border_value;
+    // FIXME: remove this crutch in deowned Mat
+    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());
 }

modules/gapi/src/backends/fluid/gfluidbuffer_priv.hpp

@@ -52,11 +52,11 @@ public:
 template<>
 class BorderHandlerT<cv::BORDER_CONSTANT> : public BorderHandler
 {
-    cv::gapi::own::Scalar m_border_value;
+    cv::Scalar m_border_value;
     cv::gapi::own::Mat m_const_border;
 
 public:
-    BorderHandlerT(int border_size, cv::gapi::own::Scalar border_value);
+    BorderHandlerT(int border_size, cv::Scalar border_value);
     virtual const uint8_t* inLineB(int log_idx, const BufferStorageWithBorder &data, int desc_height) const override;
     virtual void fillCompileTimeBorder(BufferStorageWithBorder &) override;
     virtual std::size_t size() const override;

modules/gapi/src/backends/fluid/gfluidimgproc.cpp

@@ -1525,7 +1525,7 @@ GAPI_FLUID_KERNEL(GFluidErode, cv::gapi::imgproc::GErode, true)
     #if 1
         // TODO: saturate borderValue to image type in general case (not only maximal border)
         GAPI_Assert(borderType == cv::BORDER_CONSTANT && borderValue[0] == DBL_MAX);
-        return { borderType, cv::gapi::own::Scalar::all(INT_MAX) };
+        return { borderType, cv::Scalar::all(INT_MAX) };
     #else
         return { borderType, borderValue };
     #endif
@@ -1611,7 +1611,7 @@ GAPI_FLUID_KERNEL(GFluidDilate, cv::gapi::imgproc::GDilate, true)
     #if 1
         // TODO: fix borderValue for Dilate in general case (not only minimal border)
         GAPI_Assert(borderType == cv::BORDER_CONSTANT && borderValue[0] == DBL_MAX);
-        return { borderType, cv::gapi::own::Scalar::all(INT_MIN) };
+        return { borderType, cv::Scalar::all(INT_MIN) };
     #else
         return { borderType, borderValue };
     #endif

modules/gapi/src/backends/ocl/goclbackend.cpp

@@ -129,7 +129,7 @@ cv::GArg cv::gimpl::GOCLExecutable::packArg(const GArg &arg)
     switch (ref.shape)
     {
     case GShape::GMAT:    return GArg(m_res.slot<cv::UMat>()[ref.id]);
-    case GShape::GSCALAR: return GArg(m_res.slot<cv::gapi::own::Scalar>()[ref.id]);
+    case GShape::GSCALAR: return GArg(m_res.slot<cv::Scalar>()[ref.id]);
     // Note: .at() is intentional for GArray as object MUST be already there
     //   (and constructed by either bindIn/Out or resetInternal)
     case GShape::GARRAY:  return GArg(m_res.slot<cv::detail::VectorRef>().at(ref.id));

modules/gapi/src/backends/ocl/goclkernel.cpp

@@ -19,14 +19,14 @@ cv::UMat& cv::GOCLContext::outMatR(int output)
     return (*(util::get<cv::UMat*>(m_results.at(output))));
 }
 
-const cv::gapi::own::Scalar& cv::GOCLContext::inVal(int input)
+const cv::Scalar& cv::GOCLContext::inVal(int input)
 {
-    return inArg<cv::gapi::own::Scalar>(input);
+    return inArg<cv::Scalar>(input);
 }
 
-cv::gapi::own::Scalar& cv::GOCLContext::outValR(int output)
+cv::Scalar& cv::GOCLContext::outValR(int output)
 {
-    return *util::get<cv::gapi::own::Scalar*>(m_results.at(output));
+    return *util::get<cv::Scalar*>(m_results.at(output));
 }
 
 cv::detail::VectorRef& cv::GOCLContext::outVecRef(int output)

modules/gapi/src/compiler/gobjref.hpp

@@ -28,7 +28,7 @@ namespace gimpl
 
     using ConstVal = util::variant
     < util::monostate
-    , cv::gapi::own::Scalar
+    , cv::Scalar
     >;
 
     struct RcDesc

modules/gapi/src/executor/gstreamingexecutor.cpp

@@ -112,15 +112,12 @@ void sync_data(cv::GRunArgs &results, cv::GRunArgsP &outputs)
         case T::index_of<cv::Mat*>():
             *cv::util::get<cv::Mat*>(out_obj) = std::move(cv::util::get<cv::Mat>(res_obj));
             break;
-        case T::index_of<cv::Scalar*>():
-            *cv::util::get<cv::Scalar*>(out_obj) = std::move(cv::util::get<cv::Scalar>(res_obj));
-            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<own::Scalar*>():
-            *cv::util::get<own::Scalar*>(out_obj) = std::move(cv::util::get<own::Scalar>(res_obj));
+        case T::index_of<cv::Scalar*>():
+            *cv::util::get<cv::Scalar*>(out_obj) = std::move(cv::util::get<cv::Scalar>(res_obj));
             break;
         case T::index_of<cv::detail::VectorRef>():
             cv::util::get<cv::detail::VectorRef>(out_obj).mov(cv::util::get<cv::detail::VectorRef>(res_obj));
@@ -418,7 +415,7 @@ void islandActorThread(std::vector<cv::gimpl::RcDesc> in_rcs,                //
                 isl_input.second = cv::GRunArg{cv::to_own(cv::util::get<cv::Mat>(in_arg))};
                 break;
             case cv::GRunArg::index_of<cv::Scalar>():
-                isl_input.second = cv::GRunArg{cv::to_own(cv::util::get<cv::Scalar>(in_arg))};
+                isl_input.second = cv::GRunArg{cv::util::get<cv::Scalar>(in_arg)};
                 break;
             default:
                 isl_input.second = in_arg;
@@ -443,7 +440,7 @@ void islandActorThread(std::vector<cv::gimpl::RcDesc> in_rcs,                //
             using SclType = cv::Scalar;
 #else
             using MatType = cv::gapi::own::Mat;
-            using SclType = cv::gapi::own::Scalar;
+            using SclType = cv::Scalar;
 #endif // GAPI_STANDALONE
 
             switch (r.shape) {

modules/gapi/test/gapi_async_test.cpp

@@ -388,11 +388,10 @@ namespace {
             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::Scalar*>()              :   result.emplace_back(*util::get<cv::Scalar*>(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::gapi::own::Mat*>()      :   result.emplace_back(*util::get<cv::gapi::own::Mat*>   (arg));   break;
-                case GRunArgP::index_of<cv::gapi::own::Scalar*>()   :   result.emplace_back(*util::get<cv::gapi::own::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;
                 default : ;
             }
@@ -406,11 +405,10 @@ namespace {
             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::Scalar>()              :   result.emplace_back(&util::get<cv::Scalar>(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::gapi::own::Scalar>()   :   result.emplace_back(&util::get<cv::gapi::own::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;
                 default : ;
             }

modules/gapi/test/gapi_fluid_test.cpp

@@ -75,7 +75,7 @@ TEST(FluidBuffer, CircularTest)
     const cv::Size buffer_size = {8,16};
 
     cv::gapi::fluid::Buffer buffer(cv::GMatDesc{CV_8U,1,buffer_size}, 3, 1, 0, 1,
-        util::make_optional(cv::gapi::fluid::Border{cv::BORDER_CONSTANT, cv::gapi::own::Scalar(255)}));
+        util::make_optional(cv::gapi::fluid::Border{cv::BORDER_CONSTANT, cv::Scalar(255)}));
     cv::gapi::fluid::View view = buffer.mkView(1, {});
     view.priv().reset(3);
     view.priv().allocate(3, {});

modules/gapi/test/gapi_fluid_test_kernels.cpp

@@ -184,7 +184,7 @@ GAPI_FLUID_KERNEL(FBlur3x3, TBlur3x3, false)
 
     static cv::gapi::fluid::Border getBorder(const cv::GMatDesc &/*src*/, int borderType, cv::Scalar borderValue)
     {
-        return { borderType, to_own(borderValue)};
+        return { borderType, borderValue};
     }
 };
 
@@ -200,7 +200,7 @@ GAPI_FLUID_KERNEL(FBlur5x5, TBlur5x5, false)
 
     static cv::gapi::fluid::Border getBorder(const cv::GMatDesc &/*src*/, int borderType, cv::Scalar borderValue)
     {
-        return { borderType, to_own(borderValue)};
+        return { borderType, borderValue};
     }
 };
 
@@ -217,7 +217,7 @@ GAPI_FLUID_KERNEL(FBlur3x3_2lpi, TBlur3x3_2lpi, false)
 
     static cv::gapi::fluid::Border getBorder(const cv::GMatDesc &/*src*/, int borderType, cv::Scalar borderValue)
     {
-        return { borderType, to_own(borderValue)};
+        return { borderType, borderValue};
     }
 };
 
@@ -234,7 +234,7 @@ GAPI_FLUID_KERNEL(FBlur5x5_2lpi, TBlur5x5_2lpi, false)
 
     static cv::gapi::fluid::Border getBorder(const cv::GMatDesc &/*src*/, int borderType, cv::Scalar borderValue)
     {
-        return { borderType, to_own(borderValue )};
+        return { borderType, borderValue};
     }
 };
 
@@ -261,7 +261,7 @@ GAPI_FLUID_KERNEL(FIdentity, TId, false)
 
     static gapi::fluid::Border getBorder(const cv::GMatDesc &)
     {
-        return { cv::BORDER_REPLICATE, cv::gapi::own::Scalar{} };
+        return { cv::BORDER_REPLICATE, cv::Scalar{} };
     }
 };
 
@@ -308,7 +308,7 @@ GAPI_FLUID_KERNEL(FId7x7, TId7x7, false)
 
     static cv::gapi::fluid::Border getBorder(const cv::GMatDesc&/* src*/)
     {
-        return { cv::BORDER_REPLICATE, cv::gapi::own::Scalar{} };
+        return { cv::BORDER_REPLICATE, cv::Scalar{} };
     }
 };
 

modules/gapi/test/gapi_kernel_tests.cpp

@@ -6,7 +6,6 @@
 
 
 #include "test_precomp.hpp"
-#include <opencv2/gapi/cpu/gcpukernel.hpp>
 #include "gapi_mock_kernels.hpp"
 
 #include <opencv2/gapi/cpu/gcpukernel.hpp>     // cpu::backend

modules/gapi/test/internal/gapi_int_gmetaarg_test.cpp

@@ -141,7 +141,7 @@ TEST(GMetaArg, Can_Describe_RunArg)
     constexpr int w = 3, h = 3, c = 3;
     uchar data[w*h*c];
     cv::gapi::own::Mat om(h, w, CV_8UC3, data);
-    cv::gapi::own::Scalar os;
+    cv::Scalar os;
     std::vector<int> v;
 
     GMetaArgs metas = {GMetaArg(descr_of(m)),
@@ -181,7 +181,7 @@ TEST(GMetaArg, Can_Describe_RunArgP)
     constexpr int w = 3, h = 3, c = 3;
     uchar data[w*h*c];
     cv::gapi::own::Mat om(h, w, CV_8UC3, data);
-    cv::gapi::own::Scalar os;
+    cv::Scalar os;
     std::vector<int> v;
 
     GMetaArgs metas = {GMetaArg(descr_of(m)),

modules/gapi/test/internal/gapi_int_gmodel_builder_test.cpp

@@ -166,8 +166,8 @@ TEST(GModelBuilder, Constant_GScalar)
     EXPECT_EQ(9u, static_cast<std::size_t>(g.nodes().size()));          // 6 data nodes (1 -input, 1 output, 2 constant, 2 temp) and 3 op nodes
     EXPECT_EQ(2u, static_cast<std::size_t>(addC_nh->inNodes().size())); // in and 3
     EXPECT_EQ(2u, static_cast<std::size_t>(mulC_nh->inNodes().size())); // addC output and c_s
-    EXPECT_EQ(3, (util::get<cv::gapi::own::Scalar>(gm.metadata(s_3).get<cv::gimpl::ConstValue>().arg))[0]);
-    EXPECT_EQ(5, (util::get<cv::gapi::own::Scalar>(gm.metadata(s_5).get<cv::gimpl::ConstValue>().arg))[0]);
+    EXPECT_EQ(3, (util::get<cv::Scalar>(gm.metadata(s_3).get<cv::gimpl::ConstValue>().arg))[0]);
+    EXPECT_EQ(5, (util::get<cv::Scalar>(gm.metadata(s_5).get<cv::gimpl::ConstValue>().arg))[0]);
 }
 
 TEST(GModelBuilder, Check_Multiple_Outputs)