Merge pull request opencv#17741 from aDanPin:dp/add_dinamic_graph_feature

[G-API] Allow building graphs with a dynamic number of inputs and outputs

* Add dinamic graph feature and tests

* Remove unnecessary file

* Review response

* Add implementation of operator += for GRunArgs
And test for that case

* Tests refactoring

* Add doxygen
Review response

* Fix docs

* A small documentation fix

* Review response

* Add tests for more entities

* Add typed tests

* Another typed tests

* Doc fix

* Documentation fix

* Build fix

* Commit for rebuild

* The last one

Author: aDanPin

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

@@ -102,6 +102,23 @@ using GRunArg  = util::variant<
     >;
 using GRunArgs = std::vector<GRunArg>;
 
+// TODO: Think about the addition operator
+/**
+ * @brief This operator allows to complement the input vector at runtime.
+ *
+ * It's an ordinary overload of addition assignment operator.
+ *
+ * Example of usage:
+ * @snippet dynamic_graph.cpp GRunArgs usage
+ *
+ */
+inline GRunArgs& operator += (GRunArgs &lhs, const GRunArgs &rhs)
+{
+    lhs.reserve(lhs.size() + rhs.size());
+    lhs.insert(lhs.end(), rhs.begin(), rhs.end());
+    return lhs;
+}
+
 namespace gapi
 {
 namespace wip
@@ -133,10 +150,27 @@ using GRunArgP = util::variant<
     >;
 using GRunArgsP = std::vector<GRunArgP>;
 
+// TODO: Think about the addition operator
+/**
+ * @brief This operator allows to complement the output vector at runtime.
+ *
+ * It's an ordinary overload of addition assignment operator.
+ *
+ * Example of usage:
+ * @snippet dynamic_graph.cpp GRunArgsP usage
+ *
+ */
+inline GRunArgsP& operator += (GRunArgsP &lhs, const GRunArgsP &rhs)
+{
+    lhs.reserve(lhs.size() + rhs.size());
+    lhs.insert(lhs.end(), rhs.begin(), rhs.end());
+    return lhs;
+}
+
 namespace gapi
 {
     GAPI_EXPORTS cv::GRunArgsP bind(cv::GRunArgs &results);
-}
+} // namespace gapi
 
 template<typename... Ts> inline GRunArgs gin(const Ts&... args)
 {

modules/gapi/include/opencv2/gapi/gproto.hpp

@@ -61,8 +61,29 @@ struct GIOProtoArgs
     explicit GIOProtoArgs(GProtoArgs &&args)      : m_args(std::move(args)) {}
 
     GProtoArgs m_args;
+
+    // TODO: Think about the addition operator
+    /**
+     * @brief This operator allows to complement the proto vectors at runtime.
+     *
+     * It's an ordinary overload of addition assignment operator.
+     *
+     * Example of usage:
+     * @snippet dynamic_graph.cpp  GIOProtoArgs usage
+     *
+     */
+    template<typename Tg>
+    friend GIOProtoArgs<Tg>& operator += (GIOProtoArgs<Tg> &lhs, const GIOProtoArgs<Tg> &rhs);
 };
 
+template<typename Tg>
+cv::GIOProtoArgs<Tg>& operator += (cv::GIOProtoArgs<Tg> &lhs, const cv::GIOProtoArgs<Tg> &rhs)
+{
+    lhs.m_args.reserve(lhs.m_args.size() + rhs.m_args.size());
+    lhs.m_args.insert(lhs.m_args.end(), rhs.m_args.begin(), rhs.m_args.end());
+    return lhs;
+}
+
 struct In_Tag{};
 struct Out_Tag{};
 

modules/gapi/samples/dynamic_graph.cpp

@@ -0,0 +1,68 @@
+#include <opencv2/gapi.hpp>
+#include <opencv2/gapi/core.hpp>
+#include <opencv2/gapi/cpu/core.hpp>
+
+int main(int argc, char *argv[])
+{
+    (void) argc;
+    (void) argv;
+
+    bool need_first_conversion  = true;
+    bool need_second_conversion = false;
+
+    cv::Size szOut(4, 4);
+    cv::GComputation cc([&](){
+// ! [GIOProtoArgs usage]
+        auto ins = cv::GIn();
+        cv::GMat in1;
+        if (need_first_conversion)
+            ins += cv::GIn(in1);
+
+        cv::GMat in2;
+        if (need_second_conversion)
+            ins += cv::GIn(in2);
+
+        auto outs = cv::GOut();
+        cv::GMat out1 = cv::gapi::resize(in1, szOut);
+        if (need_first_conversion)
+            outs += cv::GOut(out1);
+
+        cv::GMat out2 = cv::gapi::resize(in2, szOut);
+        if (need_second_conversion)
+            outs += cv::GOut(out2);
+// ! [GIOProtoArgs usage]
+        return cv::GComputation(std::move(ins), std::move(outs));
+    });
+
+// ! [GRunArgs usage]
+    auto in_vector = cv::gin();
+
+    cv::Mat in_mat1( 8,  8, CV_8UC3);
+    cv::Mat in_mat2(16, 16, CV_8UC3);
+    cv::randu(in_mat1, cv::Scalar::all(0), cv::Scalar::all(255));
+    cv::randu(in_mat2, cv::Scalar::all(0), cv::Scalar::all(255));
+
+    if (need_first_conversion)
+        in_vector += cv::gin(in_mat1);
+    if (need_second_conversion)
+        in_vector += cv::gin(in_mat2);
+// ! [GRunArgs usage]
+
+// ! [GRunArgsP usage]
+    auto out_vector = cv::gout();
+    cv::Mat out_mat1, out_mat2;
+    if (need_first_conversion)
+        out_vector += cv::gout(out_mat1);
+    if (need_second_conversion)
+        out_vector += cv::gout(out_mat2);
+// ! [GRunArgsP usage]
+
+    auto stream = cc.compileStreaming(cv::compile_args(cv::gapi::core::cpu::kernels()));
+    stream.setSource(std::move(in_vector));
+
+    stream.start();
+    stream.pull(std::move(out_vector));
+    stream.stop();
+
+    return 0;
+}