Merge pull request #14883 from AsyaPronina:dev/asyadev/pattern_matching

modules/gapi/CMakeLists.txt

@@ -60,6 +60,7 @@ set(gapi_srcs
     src/compiler/passes/meta.cpp
     src/compiler/passes/kernels.cpp
     src/compiler/passes/exec.cpp
+    src/compiler/passes/pattern_matching.cpp
 
     # Executor
     src/executor/gexecutor.cpp

modules/gapi/src/compiler/gmodel_priv.hpp

@@ -46,6 +46,14 @@ template<typename T> inline ade::NodeHandle dataNodeOf(const ConstLayoutGraph& g
     return detail::dataNodeOf(g, cv::gimpl::proto::origin_of(GProtoArg{t}));
 }
 
+inline ade::NodeHandle producerOf(const cv::gimpl::GModel::Graph& gm, ade::NodeHandle dh)
+{
+    GAPI_Assert(gm.metadata(dh).get<NodeType>().t == NodeType::DATA);
+    auto ins = dh->inNodes();
+    return ins.empty() ? ade::NodeHandle{ } : *ins.begin();
+}
+
+
 }}}
 
 #endif // OPENCV_GAPI_GMODEL_PRIV_HPP

modules/gapi/src/compiler/passes/pattern_matching.cpp

+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Copyright (C) 2019 Intel Corporation
+
+#include <unordered_set>
+
+#include "pattern_matching.hpp"
+
+namespace  {
+using Graph = cv::gimpl::GModel::Graph;
+using Metadata = typename Graph::CMetadataT;
+using VisitedMatchings = std::list<std::pair<ade::NodeHandle, ade::NodeHandle>>;
+
+using LabeledNodes = std::unordered_map
+                    < // reader node
+                      ade::NodeHandle
+                      // if the reader node above is:
+                      //  - DATA node: then vector is 1-element vector containing port number of
+                      //    the input edge
+                      //  - OP node: then vector is ports' vector of current connections between
+                      //    this node and an parent active DATA node
+                    , std::vector<std::size_t>
+                    , ade::HandleHasher<ade::Node>
+                    >;
+
+using MultipleMatchings = std::unordered_map
+                          // pattern OP node
+                         < ade::NodeHandle
+                          // nodes in the test graph which match to the pattern OP node above
+                          , std::vector<ade::NodeHandle>
+                          , ade::HandleHasher<ade::Node>
+                         >;
+
+// Returns true if two DATA nodes are semantically and structurally identical:
+//  - both nodes have the same GShape
+//  - both nodes are produced by the same port numbers
+//  - both nodes have the same number of output edges
+//  (output edges' ports are not checked here)
+//
+// @param first - first node to compare
+// @param firstPorts - a single element vector with first DATA node's producer output port
+// @param firstMeta - metadata of first
+// @param second - second node to compare
+// @param secondPorts - a single element vector with second DATA node's producer output port
+// @param secondMeta - metadata of second
+bool compareDataNodes(const ade::NodeHandle& first, const std::vector<std::size_t>& firstPorts,
+                      const Metadata& firstMeta,
+                      const ade::NodeHandle& second, const std::vector<std::size_t>& secondPorts,
+                      const Metadata& secondMeta) {
+    if (secondMeta.get<cv::gimpl::NodeType>().t != cv::gimpl::NodeType::DATA) {
+        throw std::logic_error("NodeType of passed node as second argument"
+                               "shall be NodeType::DATA!");
+    }
+
+    if (firstMeta.get<cv::gimpl::Data>().shape !=
+           secondMeta.get<cv::gimpl::Data>().shape) {
+        return false;
+    }
+
+    if (*firstPorts.begin() != *secondPorts.begin()) {
+        return false;
+    }
+
+    const auto& firstOutputEdges = first->outEdges();
+    const auto& secondOutputEdges = second->outEdges();
+
+    if (firstOutputEdges.size() != secondOutputEdges.size()) {
+        return false;
+    }
+
+    // FIXME: Because of new changes which introduce existence of unused DATA nodes
+    // check that first and second nodes have the same type of DATA::Storage.
+
+    return true;
+};
+
+// Returns true if two OP nodes semantically and structurally identical:
+//    - both nodes have the same kernel name
+//    - both nodes are produced by the same port numbers
+//    - if any of the nodes are in the array with visited matchings, then:
+//      first node is equal to found matching first argument and
+//      second node is equal to found matching second argument
+//
+// @param first - first node to compare
+// @param firstPorts - ports' vector of current connections between first node and an parent active
+//                     DATA node
+// @param firstMeta - metadata of first
+// @param second - second node to compare
+// @param secondPorts - ports' vector of current connections between second node and an parent
+//                      active DATA node
+// @param secondMeta - metadata of second
+// @param [out] isAlreadyVisited - set to true if first and second nodes have been already visited
+bool compareOpNodes(const VisitedMatchings& matchedVisitedNodes,
+                    const ade::NodeHandle& first, std::vector<std::size_t> firstPorts,
+                    const Metadata& firstMeta,
+                    const ade::NodeHandle& second, std::vector<std::size_t> secondPorts,
+                    const Metadata& secondMeta,
+                    bool& isAlreadyVisited) {
+    if (secondMeta.get<cv::gimpl::NodeType>().t != cv::gimpl::NodeType::OP) {
+        throw std::logic_error("NodeType of passed node as second argument shall be NodeType::OP!");
+    }
+
+    // Assuming that if kernels names are the same then
+    // output DATA nodes counts from kernels are the same.
+    // Assuming that if kernels names are the same then
+    // input DATA nodes counts to kernels are the same.
+    if (firstMeta.get<cv::gimpl::Op>().k.name != secondMeta.get<cv::gimpl::Op>().k.name) {
+        return false;
+    }
+
+    std::sort(firstPorts.begin(), firstPorts.end());
+    std::sort(secondPorts.begin(), secondPorts.end());
+    if (firstPorts != secondPorts) {
+        return false;
+    }
+
+    // Shall work, but it is good to test on the cases where multiple start pattern OP nodes
+    // maps to the test's one.
+    auto foundIt = std::find_if(matchedVisitedNodes.begin(), matchedVisitedNodes.end(),
+                               [&first, &second](const std::pair<ade::NodeHandle,
+                                                                 ade::NodeHandle>& match)
+                               {return first == match.first || second == match.second; });
+    if (foundIt != matchedVisitedNodes.end()) {
+        if (first != foundIt->first || second != foundIt->second) {
+            return false;
+        }
+
+        isAlreadyVisited = true;
+    }
+
+    return true;
+};
+
+// Retrieves and return sample from the cartesian product of candidates sets
+VisitedMatchings sampleFromProduct(std::size_t sampleIdx, // index of the sample in the product
+                                   const MultipleMatchings& candidatesSets) // map of nodes to sets
+                                                                            // of candidates
+                                                                           {
+    VisitedMatchings matchingsSample;
+
+    std::size_t quo = sampleIdx;
+    for (const auto& setForNode : candidatesSets) {
+        // TODO: order is not determined: for ex., for last node.
+        // May be use ordered set and map to ensure order?
+        auto size = setForNode.second.size();
+
+        // The below code block decodes sampleIdx into a particular sample from cartesian product
+        // of candidates sets.
+        std::size_t index = quo % size;
+        quo = quo / size;
+        const auto& candidate = setForNode.second[index];
+        matchingsSample.push_back({ setForNode.first, candidate });
+    }
+
+    return matchingsSample;
+}
+
+// Depending on type of the node retrieve port number (IN/OUT) of the edge entering this node.
+std::size_t labelOf (const ade::NodeHandle& node, // reader node
+                     const ade::EdgeHandle& edge, // edge entering the reader node
+                     const Graph& graph) // graph containing node and edge
+                                        {
+
+    if (graph.metadata(node).get<cv::gimpl::NodeType>().t == cv::gimpl::NodeType::OP) {
+        return graph.metadata(edge).get<cv::gimpl::Input>().port;
+    }
+    else {
+        return graph.metadata(edge).get<cv::gimpl::Output>().port;
+    }
+};
+
+inline bool IS_STARTPOINT(const ade::NodeHandle& nh){
+    return nh->inEdges().empty();
+}
+
+inline bool IS_ENDPOINT(const ade::NodeHandle& nh){
+    // FIXME: Because of new changes which introduce existence of unused DATA nodes
+    // Try to rely on the nh Data::Storage::OUTPUT
+    return nh->outEdges().empty();
+}
+}
+
+// Routine relies on the logic that 1 DATA node may have only 1 input edge.
+cv::gimpl::SubgraphMatch
+cv::gimpl::findMatches(const cv::gimpl::GModel::Graph& patternGraph,
+                       const cv::gimpl::GModel::Graph& testGraph) {
+
+    //TODO: Possibly, we may add N^2 check whether this graph may match or not at all.
+    //      Check that all pattern OP nodes exist in computational graph.
+
+    //---------------------------------------------------------------
+    // Identify operations which start and end our pattern
+    SubgraphMatch::S patternStartOpNodes, patternEndOpNodes;
+
+    const auto& patternInputDataNodes = patternGraph.metadata().get<cv::gimpl::Protocol>().in_nhs;
+    const auto& patternOutputDataNodes = patternGraph.metadata().get<cv::gimpl::Protocol>().out_nhs;
+
+    for (const auto& node : patternInputDataNodes) {
+        auto opNodes = node->outNodes();
+        patternStartOpNodes.insert(opNodes.begin(), opNodes.end());
+    }
+
+    for (const auto& node : patternOutputDataNodes) {
+        auto opNodes = node->inNodes();
+        // May be switched to patternEndOpNodes.insert(*opNodes.begin());
+        patternEndOpNodes.insert(opNodes.begin(), opNodes.end());
+    }
+
+    std::unordered_map<ade::NodeHandle,              // pattern OP node
+                       std::vector<ade::NodeHandle>, // nodes in the test graph which match
+                                                     // to the pattern OP node
+                       ade::HandleHasher<ade::Node>> allMatchingsForStartOpNodes;
+
+    //Filling of allMatchingsForStartOpNodes
+    std::size_t possibleStartPointsCount = 1;
+
+    // For every starting OP node of pattern identify matching candidates(there may be many)
+    // in test graph.
+    auto testOpNodes = ade::util::filter(testGraph.nodes(),
+                                         [&](const ade::NodeHandle& node) {
+                                             return testGraph.metadata(node).
+                                                        get<cv::gimpl::NodeType>().t
+                                                    == cv::gimpl::NodeType::OP;
+                                         });
+    for (const auto& patternStartOpNode : patternStartOpNodes) {
+        const auto& patternOpMeta = patternGraph.metadata(patternStartOpNode);
+
+        auto& possibleMatchings = allMatchingsForStartOpNodes[patternStartOpNode];
+        std::copy_if(testOpNodes.begin(), testOpNodes.end(), std::back_inserter(possibleMatchings),
+            [&](const ade::NodeHandle& testOpNode) {
+                const auto& testOpMeta = testGraph.metadata(testOpNode);
+
+                bool stub = false;
+                return compareOpNodes({ },
+                                      patternStartOpNode, {  }, patternOpMeta,
+                                      testOpNode, {  }, testOpMeta,
+                                      stub);
+            });
+
+        if (possibleMatchings.size() == 0) {
+            // Pattern graph is not matched
+            return SubgraphMatch { };
+        }
+
+        possibleStartPointsCount *= possibleMatchings.size();
+    }
+
+    SubgraphMatch::M subgraphStartOps;
+    SubgraphMatch::M subgraphEndOps;
+    // FIXME: consider moving to S
+    std::list<ade::NodeHandle> subgraphInternals;
+
+
+    // Structural matching first, semantic matching second.
+
+    // 'patternFound' means pattern is matched.
+    bool patternFound = false;
+    std::size_t i = 0;
+    while (!patternFound && (i < possibleStartPointsCount)) {
+        subgraphStartOps.clear();
+        subgraphEndOps.clear();
+        subgraphInternals.clear();
+
+        // List of the pairs representing matchings of pattern node to the test node.
+        VisitedMatchings matchedVisitedNodes;
+
+        // Cartesian product of candidate sets for start OP nodes gives set of samples
+        // as possible matchings for start OP nodes.
+        // Let allMatchingsForStartOpNodes looks like:  x1 : [ y1 ]
+        //                                              x2 : [ y2, y3 ]
+        // Cartesian product of two these candidates sets (for x1 and x2 pattern nodes
+        // correspondingly) produces two samples of matchings for x1, x2:
+        //                         [ (x1, y1), (x2, y2) ]
+        //                         [ (x1, y1), (x2, y3) ]
+        //
+
+        // Here we fill matchedVisitedNodes list with the next sample from the cartesian product
+        // of candidates sets.
+        // i is traversing full cartesian product of candidates sets.
+        matchedVisitedNodes = sampleFromProduct(i, allMatchingsForStartOpNodes);
+
+        bool stop = false;
+
+        // matchIt is an iterator to a pair of pattern ade::NodeHandle to test's ade::nodeHandle.
+        auto matchIt = matchedVisitedNodes.begin();
+        std::size_t size = matchedVisitedNodes.size();
+
+        while (!stop) {
+            // The following loop traverses through the current level of matchings.
+            // Every iteration we consider only one certain pair of matched nodes.
+            for (std::size_t index = 0u; index < size && !stop; ++index, ++matchIt) {
+
+                // Check if a given matchIt->first node is an pattern-ending OP node.
+                // If it is just remember it in a special map.
+                bool cond1 = std::find(patternEndOpNodes.begin(),
+                                       patternEndOpNodes.end(),
+                                       matchIt->first)
+                             != patternEndOpNodes.end();
+                if (cond1) {
+                    subgraphEndOps[matchIt->first] = matchIt->second;
+                }
+
+                // Check if a given matchIt->first node is an pattern-starting OP node.
+                // If it is just remember it in a special map.
+                bool cond2 = std::find(patternStartOpNodes.begin(),
+                                       patternStartOpNodes.end(),
+                                       matchIt->first)
+                             != patternStartOpNodes.end();
+                if (cond2) {
+                    subgraphStartOps[matchIt->first] = matchIt->second;
+                }
+
+                // If neither of conditions are true mark the test node as an internal one.
+                if (!cond1 && !cond2) {
+                    subgraphInternals.push_back(matchIt->second);
+                }
+
+                //-------------------------------------------------------------------------------
+                // Given the current pattern/test matching of nodes, traverse their descendants.
+                // For every descendant store the port of the edge connecting to it.
+                // NOTE: the nature of port number may vary: it may be either IN for OP nodes
+                // or OUT for DATA ones
+                LabeledNodes patternOutputNodesLabeled;
+                LabeledNodes testOutputNodesLabeled;
+
+                auto patternOutputEdges = matchIt->first->outEdges();
+                auto testOutputEdges = matchIt->second->outEdges();
+
+                for (const auto& patternOutputEdge : patternOutputEdges) {
+                    const auto& dstNh = patternOutputEdge->dstNode();
+                    if (!IS_ENDPOINT(dstNh)) {
+                        //Assuming that there is no case for the op node without output data nodes.
+                        patternOutputNodesLabeled[dstNh].
+                                push_back(labelOf(dstNh, patternOutputEdge, patternGraph));
+                    }
+                }
+
+                for (const auto& testOutputEdge : testOutputEdges) {
+                    const auto& dstNh = testOutputEdge->dstNode();
+                    testOutputNodesLabeled[dstNh].
+                            push_back(labelOf(dstNh, testOutputEdge, testGraph));
+                }
+
+                //---------------------------------------------------------------------------------
+                // Traverse through labeled descendants of pattern node and for every descedant
+                // find a matching in labeled descendants of corresponding test node
+                for (const auto& patternNode : patternOutputNodesLabeled) {
+                    bool isAlreadyVisited = false;
+                    const auto& patternNodeMeta = patternGraph.metadata(patternNode.first);
+
+                    auto testIt = std::find_if(testOutputNodesLabeled.begin(),
+                                               testOutputNodesLabeled.end(),
+                        [&](const std::pair<const ade::NodeHandle,
+                                           std::vector<std::size_t>>& testNode) {
+                        const auto& testNodeMeta = testGraph.metadata(testNode.first);
+
+                        auto patternNodeType = patternNodeMeta.get<cv::gimpl::NodeType>().t;
+
+                        switch(patternNodeType) {
+                        case cv::gimpl::NodeType::DATA:
+                            return compareDataNodes(patternNode.first, patternNode.second,
+                                                    patternNodeMeta,
+                                                    testNode.first, testNode.second,
+                                                    testNodeMeta);
+                        case cv::gimpl::NodeType::OP:
+                            return compareOpNodes(matchedVisitedNodes,
+                                                  patternNode.first, patternNode.second,
+                                                  patternNodeMeta,
+                                                  testNode.first, testNode.second,
+                                                  testNodeMeta,
+                                                  isAlreadyVisited);
+                        default:
+                            GAPI_Assert(false && "Unsupported Node type!");
+                        }
+
+                        return false;
+                    });
+
+                    if (testIt == testOutputNodesLabeled.end()) {
+                        stop = true;
+                        break;
+                    }
+
+                    // Update matchedVisitedNodes list with found pair of nodes if the pair
+                    // has not been visited before.
+                    if (!isAlreadyVisited) {
+                        matchedVisitedNodes.push_back({ patternNode.first, testIt->first });
+                    }
+                } // Loop traversed patternOutputNodesLabeled
+            } // Loop traversed matchedVisitedNodes
+
+            // Suppose, pattern and test graphs' structures without input DATA nodes look like:
+            //         Pattern graph                Test graph
+            //        op1       op2               t_op1      t_op2
+            //      +-----+   +-----+            +-----+    +-----+
+            //      v     v   v     v            v     v    v     v
+            //      d1    d2  d3    d4          t_d1  t_d2 t_d3  t_d4
+            //      v     v   v     v            v     v    v     v
+            //     ...   ... ...   ...          ...   ...  ...   ...
+
+            // matchedVisitedNodes content before previous loop execution:
+            //     op1 <--> t_op1, op2 <--> t_op2
+            // matchedVisitedNodes content after previous loop execution (extended with the next
+            // level of matchings):
+            //     op1 <--> t_op1, op2 <--> t_op2 | d1 <--> t_d1, d2 <--> t_d2, d3 <--> t_d3, d4 <--> t_d4
+            //                                           ^
+            //                                           |
+            //                                      matchIt
+            //
+            // matchIt iterator points to the first matching in next level if the next level exists.
+            // If there is no next level, matchIt == matchedVisitedNodes.end() and all pattern
+            // levels (except ones for IN/OUT data nodes) have been already processed, so,
+            // pattern subgraph is found.
+
+            if (!stop) {
+                // Check if pattetn subgraph is found
+                if (matchIt == matchedVisitedNodes.end()) {
+                    // Found
+                    stop = true;
+                    patternFound = true;
+                }
+
+                // Update 'size' with the size of the new level of matchings
+                size = static_cast<std::size_t>(std::distance(matchIt, matchedVisitedNodes.end()));
+            }
+        }
+
+        if (!patternFound){
+            // Pattern subgraph is not matched.
+            // Switch to the next combination of starting points
+            ++i;
+            continue;
+        }
+
+        SubgraphMatch::M inputApiMatch;
+        SubgraphMatch::M outputApiMatch;
+
+        // Traversing current result for starting OPs
+        for (auto it = subgraphStartOps.begin();
+                it != subgraphStartOps.end() && patternFound; ++it) {
+            const auto& match = *it;
+            auto patternInputEdges = match.first->inEdges();
+            auto testInputEdges = match.second->inEdges();
+
+            SubgraphMatch::S patternUniqInNodes(match.first->inNodes().begin(),
+                                                match.first->inNodes().end());
+            SubgraphMatch::S testUniqInNodes(match.second->inNodes().begin(),
+                                             match.second->inNodes().end());
+
+            if (patternUniqInNodes.size() < testUniqInNodes.size()) {
+                inputApiMatch.clear();
+                patternFound = false;
+                break;
+            }
+            // Else, patternInNodes.size() > testInNodes.size() is considered as valid case.
+
+            // Match pattern input DATA nodes with boundary matched test DATA nodes.
+            for (const auto& patternInEdge : patternInputEdges) {
+
+                // Not all start OP nodes are located in the beginning of the pattern graph
+                // Start OP may have one input DATA node as an Protocol IN node and other
+                // input DATA nodes produced from another operations
+                if (!IS_STARTPOINT(patternInEdge->srcNode())) {
+                    continue;
+                }
+
+                auto patternInputPort =
+                        patternGraph.metadata(patternInEdge).get<cv::gimpl::Input>().port;
+
+                auto matchedIt = std::find_if(testInputEdges.begin(), testInputEdges.end(),
+                    [&](const ade::EdgeHandle& testInEdge) -> bool {
+                    auto testInputPort =
+                            testGraph.metadata(testInEdge).get<cv::gimpl::Input>().port;
+
+                    if (patternInputPort != testInputPort) {
+                        return false;
+                    }
+
+                    auto foundIt = inputApiMatch.find(patternInEdge->srcNode());
+                    if (foundIt != inputApiMatch.end()) {
+                        if (testInEdge->srcNode() != foundIt->second) {
+                            return false;
+                        }
+                        return true;
+                    }
+
+                    // Update inputApiMatch map only if the pair of nodes isn't in the map already
+                    inputApiMatch[patternInEdge->srcNode()] = testInEdge->srcNode();
+                    return true;
+                });
+
+                if (matchedIt == testInputEdges.end()) {
+                    inputApiMatch.clear();
+                    patternFound  = false;
+                    break;
+                }
+            } // Loop traversed patternInputEdges
+        } // Loop traversed sugraphStartOps
+
+        if (!patternFound) {
+            // Pattern IN data nodes can not be matched.
+            // Switch to the next combination of starting points
+            ++i;
+            continue;
+        }
+
+        // Create vector with the correctly ordered IN data nodes in the test subgraph
+        std::vector<ade::NodeHandle> inputTestDataNodes;
+        for (const auto& patternInNode : patternInputDataNodes) {
+            inputTestDataNodes.push_back(inputApiMatch[patternInNode]);
+        }
+
+        // Traversing current result for ending OPs
+        // There is an assumption that if the pattern subgraph is matched, then
+        // OUT data nodes shall be definitely matched
+        for (const auto& match : subgraphEndOps) {
+            auto patternOutputEdges = match.first->outEdges();
+            auto testOutputEdges = match.second->outEdges();
+
+            GAPI_Assert(patternOutputEdges.size() == testOutputEdges.size()
+                        &&
+                        "Ending OP nodes are matched, so OPs' outputs count shall be the same!");
+
+            // Match pattern output DATA nodes with boundary matched test DATA nodes.
+            for (const auto& patternOutEdge : patternOutputEdges) {
+
+                // Not all end OP nodes are located in the ending of the pattern graph
+                // End OP node may have one output DATA node as an Protocol OUT node and other
+                // output DATA nodes as input for another operations
+                if (!IS_ENDPOINT(patternOutEdge->dstNode())) {
+                    continue;
+                }
+
+                auto patternOutputPort =
+                        patternGraph.metadata(patternOutEdge).get<cv::gimpl::Output>().port;
+
+                auto matchedIt = std::find_if(testOutputEdges.begin(), testOutputEdges.end(),
+                    [&](const ade::EdgeHandle& testOutEdge) -> bool {
+                    auto testOutputPort =
+                            testGraph.metadata(testOutEdge).get<cv::gimpl::Output>().port;
+
+                    if (patternOutputPort != testOutputPort) {
+                        return false;
+                    }
+
+                    outputApiMatch[patternOutEdge->dstNode()] = testOutEdge->dstNode();
+                    return true;
+                });
+
+                GAPI_Assert(matchedIt != testOutputEdges.end()
+                            &&
+                            "There shall be a match for every OUT data node from ending OP node,"
+                            "if ending OP node matches");
+            }
+
+        }
+
+        // Create vector with the correctly ordered OUT data nodes in the test subgraph
+        std::vector<ade::NodeHandle> outputTestDataNodes;
+        for (const auto& patternOutNode : patternOutputDataNodes) {
+            outputTestDataNodes.push_back(outputApiMatch[patternOutNode]);
+        }
+
+        SubgraphMatch subgraph;
+
+        subgraph.inputDataNodes = std::move(inputApiMatch);
+        subgraph.startOpNodes = std::move(subgraphStartOps);
+        subgraph.internalLayers = std::move(subgraphInternals);
+        subgraph.finishOpNodes = std::move(subgraphEndOps);
+        subgraph.outputDataNodes = std::move(outputApiMatch);
+
+        subgraph.inputTestDataNodes = std::move(inputTestDataNodes);
+        subgraph.outputTestDataNodes = std::move(outputTestDataNodes);
+
+        return subgraph;
+
+    }
+
+    return SubgraphMatch { };
+}

modules/gapi/src/compiler/passes/pattern_matching.hpp

+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Copyright (C) 2019 Intel Corporation
+
+
+#ifndef OPENCV_GAPI_PATTERN_MATCHING_HPP
+#define OPENCV_GAPI_PATTERN_MATCHING_HPP
+
+#include <unordered_map>
+#include <unordered_set>
+#include <vector>
+#include <list>
+
+#include "compiler/gmodel.hpp"
+
+namespace cv {
+namespace gimpl {
+
+    struct SubgraphMatch {
+        using M =  std::unordered_map< ade::NodeHandle              // Pattern graph node
+                                     , ade::NodeHandle              // Test graph node
+                                     , ade::HandleHasher<ade::Node>
+                                     >;
+        using S =  std::unordered_set< ade::NodeHandle
+                                     , ade::HandleHasher<ade::Node>
+                                     >;
+        M inputDataNodes;
+        M startOpNodes;
+        M finishOpNodes;
+        M outputDataNodes;
+
+        std::vector<ade::NodeHandle> inputTestDataNodes;
+        std::vector<ade::NodeHandle> outputTestDataNodes;
+
+        std::list<ade::NodeHandle> internalLayers;
+
+        // FIXME: switch to operator bool() instead
+        bool ok() const {
+            return    !inputDataNodes.empty() && !startOpNodes.empty()
+                   && !finishOpNodes.empty() && !outputDataNodes.empty()
+                   && !inputTestDataNodes.empty() && !outputTestDataNodes.empty();
+
+        }
+
+       S nodes() const {
+           S allNodes {};
+
+           allNodes.insert(inputTestDataNodes.begin(), inputTestDataNodes.end());
+
+           for (const auto& startOpMatch : startOpNodes) {
+               allNodes.insert(startOpMatch.second);
+           }
+
+           for (const auto& finishOpMatch : finishOpNodes) {
+               allNodes.insert(finishOpMatch.second);
+           }
+
+           allNodes.insert(outputTestDataNodes.begin(), outputTestDataNodes.end());
+
+           allNodes.insert(internalLayers.begin(), internalLayers.end());
+
+           return allNodes;
+       }
+
+       S startOps() {
+            S sOps;
+            for (const auto& opMatch : startOpNodes) {
+               sOps.insert(opMatch.second);
+            }
+            return sOps;
+       }
+
+       S finishOps() {
+            S fOps;
+            for (const auto& opMatch : finishOpNodes) {
+               fOps.insert(opMatch.second);
+            }
+            return fOps;
+       }
+
+       std::vector<ade::NodeHandle> protoIns() {
+           return inputTestDataNodes;
+       }
+
+
+       std::vector<ade::NodeHandle> protoOuts() {
+           return outputTestDataNodes;
+       }
+    };
+
+    GAPI_EXPORTS SubgraphMatch findMatches(const cv::gimpl::GModel::Graph& patternGraph,
+                                           const cv::gimpl::GModel::Graph& compGraph);
+
+} //namespace gimpl
+} //namespace cv
+#endif // OPENCV_GAPI_PATTERN_MATCHING_HPP

modules/gapi/test/common/gapi_core_tests_inl.hpp

@@ -14,7 +14,7 @@
 namespace opencv_test
 {
 
-TEST_P(MathOpTest, MatricesAccuracyTest )
+TEST_P(MathOpTest, MatricesAccuracyTest)
 {
     // G-API code & corresponding OpenCV code ////////////////////////////////
     cv::GMat in1, in2, out;

modules/gapi/test/internal/gapi_int_pattern_matching_test.cpp

+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Copyright (C) 2019 Intel Corporation
+
+
+#include "../test_precomp.hpp"
+
+#include <stdexcept>
+
+#include "compiler/gmodel.hpp"
+#include "compiler/gmodel_priv.hpp"
+
+#include "api/gcomputation_priv.hpp"
+#include "compiler/gcompiler.hpp"
+#include "compiler/gmodelbuilder.hpp"
+#include "compiler/passes/passes.hpp"
+
+#include "compiler/passes/pattern_matching.hpp"
+
+#include "../common/gapi_tests_common.hpp"
+
+#include "logger.hpp"
+
+namespace opencv_test
+{
+
+namespace matching_test {
+namespace  {
+using V = std::vector<ade::NodeHandle>;
+using S =  std::unordered_set< ade::NodeHandle
+                             , ade::HandleHasher<ade::Node>
+                             >;
+
+void initGModel(ade::Graph& gr,
+                cv::GProtoInputArgs&& in,
+                cv::GProtoOutputArgs&& out) {
+
+    cv::gimpl::GModel::Graph gm(gr);
+    cv::gimpl::GModel::init(gm);
+    auto proto_slots = cv::gimpl::GModelBuilder(gr)
+            .put(in.m_args, out.m_args);
+
+    cv::gimpl::Protocol p;
+    std::tie(p.inputs, p.outputs, p.in_nhs, p.out_nhs) = proto_slots;
+    gm.metadata().set(p);
+}
+
+bool isConsumedBy(cv::gimpl::GModel::Graph gm, ade::NodeHandle data_nh, ade::NodeHandle op_nh) {
+    auto oi = cv::gimpl::GModel::orderedInputs(gm, op_nh);
+    return std::find(oi.begin(), oi.end(), data_nh) != oi.end();
+}
+
+std::string opName(cv::gimpl::GModel::Graph gm, ade::NodeHandle op_nh) {
+    return gm.metadata(op_nh).get<cv::gimpl::Op>().k.name;
+}
+
+}
+} // matching_test
+
+TEST(PatternMatching, TestFuncDoesNotChangeTestGraph)
+{
+    // Pattern
+    ade::Graph pg;
+    {
+        GMat in;
+        GMat out = cv::gapi::bitwise_not(in);
+        matching_test::initGModel(pg, cv::GIn(in), cv::GOut(out));
+    }
+
+    // Test
+    ade::Graph tg;
+    GMat in;
+    GMat out = cv::gapi::bitwise_not(in);
+    matching_test::initGModel(tg, cv::GIn(in), cv::GOut(out));
+
+    // Pattern Matching
+    cv::gimpl::GModel::Graph pgm(pg);
+    cv::gimpl::GModel::Graph tgm(tg);
+    cv::gimpl::findMatches(pg, tg);
+
+    // Inspecting results:
+    matching_test::S nodes{ tgm.nodes().begin(), tgm.nodes().end() };
+
+    const auto in_nh = cv::gimpl::GModel::dataNodeOf(tgm, in);
+    const auto out_nh = cv::gimpl::GModel::dataNodeOf(tgm, out);
+
+    auto input_data_nhs = tgm.metadata().get<cv::gimpl::Protocol>().in_nhs;
+    auto output_data_nhs = tgm.metadata().get<cv::gimpl::Protocol>().out_nhs;
+
+    EXPECT_EQ(1u, input_data_nhs.size());
+    EXPECT_EQ(1u, output_data_nhs.size());
+    EXPECT_EQ(in_nh, *input_data_nhs.begin());
+    EXPECT_EQ(out_nh, *output_data_nhs.begin());
+    EXPECT_EQ(0u, in_nh->inEdges().size());
+    EXPECT_EQ(0u, out_nh->outEdges().size());
+    EXPECT_EQ(1u, in_nh->outEdges().size());
+    EXPECT_EQ(1u, out_nh->inEdges().size());
+
+    const auto op_nh = cv::gimpl::GModel::producerOf(tgm, out_nh); //bitwise_not
+    EXPECT_EQ(cv::gapi::core::GNot::id(), matching_test::opName(tgm, op_nh));
+    EXPECT_EQ(1u, op_nh->inEdges().size());
+    EXPECT_TRUE(matching_test::isConsumedBy(tgm, in_nh, op_nh));
+    EXPECT_EQ(1u, op_nh->outEdges().size());
+}
+
+TEST(PatternMatching, TestSimple1)
+{
+    // Pattern
+    ade::Graph pg;
+    {
+        GMat in;
+        GMat out = cv::gapi::bitwise_not(in);
+        matching_test::initGModel(pg, cv::GIn(in), cv::GOut(out));
+   }
+
+    // Test
+    ade::Graph tg;
+    GMat in;
+    GMat out = cv::gapi::bitwise_not(in);
+    matching_test::initGModel(tg, cv::GIn(in), cv::GOut(out));
+
+    // Pattern Matching
+    cv::gimpl::GModel::Graph pgm(pg);
+    cv::gimpl::GModel::Graph tgm(tg);
+    cv::gimpl::SubgraphMatch match = cv::gimpl::findMatches(pg, tg);
+
+    // Inspecting results:
+    EXPECT_TRUE(match.ok());
+
+    auto nodes = match.nodes();
+    EXPECT_EQ(3u, nodes.size());
+
+    const auto in_nh = cv::gimpl::GModel::dataNodeOf(tgm, in);
+    const auto out_nh = cv::gimpl::GModel::dataNodeOf(tgm, out);
+    const auto op_nh = cv::gimpl::GModel::producerOf(tgm, out_nh);
+
+    EXPECT_EQ(matching_test::S({in_nh, out_nh, op_nh}), nodes);
+    EXPECT_EQ(cv::gapi::core::GNot::id(), matching_test::opName(tgm, op_nh));
+    EXPECT_TRUE(matching_test::isConsumedBy(tgm, in_nh, op_nh));
+    EXPECT_EQ(matching_test::S{op_nh}, match.startOps());
+    EXPECT_EQ(matching_test::S{op_nh}, match.finishOps());
+    EXPECT_EQ(matching_test::V{in_nh}, match.protoIns());
+    EXPECT_EQ(matching_test::V{out_nh}, match.protoOuts());
+}
+
+TEST(PatternMatching, TestSimple2)
+{
+    // Pattern
+    ade::Graph pg;
+    {
+        GMat in;
+        GMat out = cv::gapi::bitwise_not(in);
+        matching_test::initGModel(pg, cv::GIn(in), cv::GOut(out));
+   }
+
+    // Test
+    ade::Graph tg;
+    GMat in;
+    GMat tmp = cv::gapi::bitwise_not(in);
+    GMat out = cv::gapi::blur(tmp, cv::Size(3, 3));
+    matching_test::initGModel(tg, cv::GIn(in), cv::GOut(out));
+
+    // Pattern Matching
+    cv::gimpl::GModel::Graph pgm(pg);
+    cv::gimpl::GModel::Graph tgm(tg);
+    cv::gimpl::SubgraphMatch match = cv::gimpl::findMatches(pg, tg);
+
+    // Inspecting results:
+    EXPECT_TRUE(match.ok());
+
+    auto nodes = match.nodes();
+    EXPECT_EQ(3u, nodes.size());
+
+    const auto in_nh = cv::gimpl::GModel::dataNodeOf(tgm, in);
+    const auto tmp_nh = cv::gimpl::GModel::dataNodeOf(tgm, tmp);
+    const auto op_nh = cv::gimpl::GModel::producerOf(tgm, tmp_nh);
+
+    EXPECT_EQ(matching_test::S({in_nh, tmp_nh, op_nh}), nodes);
+    EXPECT_EQ(cv::gapi::core::GNot::id(), matching_test::opName(tgm, op_nh));
+    EXPECT_TRUE(matching_test::isConsumedBy(tgm, in_nh, op_nh));
+    EXPECT_EQ(matching_test::S{op_nh}, match.startOps());
+    EXPECT_EQ(matching_test::S{op_nh}, match.finishOps());
+    EXPECT_EQ(matching_test::V{in_nh}, match.protoIns());
+    EXPECT_EQ(matching_test::V{tmp_nh}, match.protoOuts());
+}
+
+TEST(PatternMatching, TestSimple3)
+{
+    // Pattern
+    ade::Graph pg;
+    {
+        GMat in;
+        GMat out = cv::gapi::bitwise_not(in);
+        matching_test::initGModel(pg, cv::GIn(in), cv::GOut(out));
+   }
+
+    // Test
+    ade::Graph tg;
+    GMat in;
+    GMat tmp = cv::gapi::blur(in, cv::Size(3, 3));
+    GMat out = cv::gapi::bitwise_not(tmp);
+    matching_test::initGModel(tg, cv::GIn(in), cv::GOut(out));
+
+    // Pattern Matching
+    cv::gimpl::GModel::Graph pgm(pg);
+    cv::gimpl::GModel::Graph tgm(tg);
+    cv::gimpl::SubgraphMatch match = cv::gimpl::findMatches(pg, tg);
+
+    // Inspecting results:
+    EXPECT_TRUE(match.ok());
+
+    auto nodes = match.nodes();
+    EXPECT_EQ(3u, nodes.size());
+
+    const auto tmp_nh = cv::gimpl::GModel::dataNodeOf(tgm, tmp);
+    const auto out_nh = cv::gimpl::GModel::dataNodeOf(tgm, out);
+    const auto op_nh = cv::gimpl::GModel::producerOf(tgm, out_nh);
+
+    EXPECT_EQ(matching_test::S({tmp_nh, out_nh, op_nh}), nodes);
+    EXPECT_EQ(cv::gapi::core::GNot::id(), matching_test::opName(tgm, op_nh));
+    EXPECT_TRUE(matching_test::isConsumedBy(tgm, tmp_nh, op_nh));
+    EXPECT_EQ(matching_test::S{op_nh}, match.startOps());
+    EXPECT_EQ(matching_test::S{op_nh}, match.finishOps());
+    EXPECT_EQ(matching_test::V{tmp_nh}, match.protoIns());
+    EXPECT_EQ(matching_test::V{out_nh}, match.protoOuts());
+}
+
+TEST(PatternMatching, TestMultiplePatternOuts)
+{
+    // Pattern
+    ade::Graph pg;
+    {
+        GMat in;
+        GMat dx, dy;
+        std::tie(dx, dy) = cv::gapi::SobelXY(in, -1, 1);
+        matching_test::initGModel(pg, cv::GIn(in), cv::GOut(dx, dy));
+   }
+
+    // Test
+    ade::Graph tg;
+    GMat in;
+    GMat dx, dy;
+    std::tie(dx, dy) = cv::gapi::SobelXY(in, -1, 1);
+    matching_test::initGModel(tg, cv::GIn(in), cv::GOut(dx, dy));
+
+    // Pattern Matching
+    cv::gimpl::GModel::Graph pgm(pg);
+    cv::gimpl::GModel::Graph tgm(tg);
+    cv::gimpl::SubgraphMatch match = cv::gimpl::findMatches(pg, tg);
+
+    // Inspecting results:
+    EXPECT_TRUE(match.ok());
+
+    auto nodes = match.nodes();
+    EXPECT_EQ(4u, nodes.size());
+
+    const auto in_nh = cv::gimpl::GModel::dataNodeOf(tgm, in);
+    const auto dx_nh = cv::gimpl::GModel::dataNodeOf(tgm, dx);
+    const auto dy_nh = cv::gimpl::GModel::dataNodeOf(tgm, dy);
+    const auto op_nh = cv::gimpl::GModel::producerOf(tgm, dx_nh);
+    EXPECT_EQ(op_nh,  cv::gimpl::GModel::producerOf(tgm, dy_nh));
+
+    EXPECT_EQ(matching_test::S({in_nh, dx_nh, dy_nh, op_nh}), nodes);
+    EXPECT_EQ(cv::gapi::imgproc::GSobelXY::id(), matching_test::opName(tgm, op_nh));
+    EXPECT_TRUE(matching_test::isConsumedBy(tgm, in_nh, op_nh));
+    EXPECT_EQ(matching_test::S{op_nh}, match.startOps());
+    EXPECT_EQ(matching_test::S{op_nh}, match.finishOps());
+    EXPECT_EQ(matching_test::V{in_nh}, match.protoIns());
+    EXPECT_EQ(matching_test::V({dx_nh, dy_nh}), match.protoOuts());
+}
+
+TEST(PatternMatching, TestPreprocSplit3)
+{
+    // Pattern
+    ade::Graph pg;
+    {
+        GMat in;
+        GMat tmp = cv::gapi::resize(in, cv::Size{224, 224});
+        GMat b, g, r;
+        std::tie(b, g, r) = cv::gapi::split3(tmp);
+        matching_test::initGModel(pg, cv::GIn(in), cv::GOut(b, g, r));
+    }
+
+    // Test
+    ade::Graph tg;
+    GMat y, uv;
+    GMat bgr = cv::gapi::NV12toBGR(y, uv);
+    GMat tmp = cv::gapi::resize(bgr, cv::Size{224, 224});
+    GMat b, g, r;
+    std::tie(b, g, r) = cv::gapi::split3(tmp);
+    matching_test::initGModel(tg, cv::GIn(y, uv), cv::GOut(b, g, r));
+
+    // Pattern Matching
+    cv::gimpl::GModel::Graph pgm(pg);
+    cv::gimpl::GModel::Graph tgm(tg);
+    cv::gimpl::SubgraphMatch match = cv::gimpl::findMatches(pg, tg);
+
+    // Inspecting results:
+    EXPECT_TRUE(match.ok());
+
+    auto nodes = match.nodes();
+    EXPECT_EQ(7u, nodes.size());
+
+    const auto bgr_nh = cv::gimpl::GModel::dataNodeOf(tgm, bgr);
+    const auto tmp_nh = cv::gimpl::GModel::dataNodeOf(tgm, tmp);
+    const auto b_nh = cv::gimpl::GModel::dataNodeOf(tgm, b);
+    const auto g_nh = cv::gimpl::GModel::dataNodeOf(tgm, g);
+    const auto r_nh = cv::gimpl::GModel::dataNodeOf(tgm, r);
+
+    const auto op1_nh = cv::gimpl::GModel::producerOf(tgm, tmp_nh); // 1st resize
+    const auto op2_nh = cv::gimpl::GModel::producerOf(tgm, b_nh); // 2nd split3
+    EXPECT_EQ(op2_nh, cv::gimpl::GModel::producerOf(tgm, g_nh));
+    EXPECT_EQ(op2_nh, cv::gimpl::GModel::producerOf(tgm, r_nh));
+
+    EXPECT_EQ(matching_test::S({bgr_nh, tmp_nh,   b_nh,   g_nh,
+                                          r_nh, op1_nh, op2_nh}),
+              nodes);
+
+    EXPECT_EQ(cv::gapi::core::GResize::id(), matching_test::opName(tgm, op1_nh));
+    EXPECT_EQ(cv::gapi::core::GSplit3::id(), matching_test::opName(tgm, op2_nh));
+
+    EXPECT_EQ(1u, tmp_nh->outEdges().size());
+    EXPECT_TRUE(matching_test::isConsumedBy(tgm, bgr_nh, op1_nh));
+    EXPECT_TRUE(matching_test::isConsumedBy(tgm, tmp_nh, op2_nh));
+
+    EXPECT_EQ(matching_test::S{ op1_nh }, match.startOps());
+    EXPECT_EQ(matching_test::S{ op2_nh }, match.finishOps());
+    EXPECT_EQ(matching_test::V{ bgr_nh }, match.protoIns());
+    EXPECT_EQ(matching_test::V({ b_nh, g_nh, r_nh }), match.protoOuts());
+}
+
+G_TYPED_KERNEL(GToNCHW, <GMatP(GMat)>, "test.toNCHW") {
+    static GMatDesc outMeta(GMatDesc in) {
+        GAPI_Assert(in.depth == CV_8U);
+        GAPI_Assert(in.chan == 3);
+        GAPI_Assert(in.planar == false);
+        return in.asPlanar();
+    }
+};
+
+static GMat toNCHW(const GMat& src)
+{
+    return GToNCHW::on(src);
+}
+
+TEST(PatternMatching, TestPreprocToNCHW)
+{
+    // Pattern
+    ade::Graph pg;
+    {
+        GMat in;
+        GMat tmp = cv::gapi::resize(in, cv::Size{224, 224});
+        GMat plr = toNCHW(tmp);
+        matching_test::initGModel(pg, cv::GIn(in), cv::GOut(plr));
+    }
+
+    // Test
+    ade::Graph tg;
+    GMat y, uv;
+    GMat bgr = cv::gapi::NV12toBGR(y, uv);
+    GMat tmp = cv::gapi::resize(bgr, cv::Size{224, 224});
+    GMat plr = toNCHW(tmp);
+    matching_test::initGModel(tg, cv::GIn(y, uv), cv::GOut(plr));
+
+    // Pattern Matching
+    cv::gimpl::GModel::Graph pgm(pg);
+    cv::gimpl::GModel::Graph tgm(tg);
+    cv::gimpl::SubgraphMatch match = cv::gimpl::findMatches(pg, tg);
+
+    // Inspecting results:
+    EXPECT_TRUE(match.ok());
+
+    auto nodes = match.nodes();
+    EXPECT_EQ(5u, nodes.size());
+
+    const auto bgr_nh = cv::gimpl::GModel::dataNodeOf(tgm, bgr);
+    const auto tmp_nh = cv::gimpl::GModel::dataNodeOf(tgm, tmp);
+    const auto plr_nh = cv::gimpl::GModel::dataNodeOf(tgm, plr);
+
+    const auto op1_nh = cv::gimpl::GModel::producerOf(tgm, tmp_nh); // 1st resize
+    const auto op2_nh = cv::gimpl::GModel::producerOf(tgm, plr_nh); // 2nd toNCHW
+
+    EXPECT_EQ(matching_test::S({bgr_nh, tmp_nh, plr_nh, op1_nh, op2_nh}),
+              nodes);
+
+    EXPECT_EQ(cv::gapi::core::GResize::id(), matching_test::opName(tgm, op1_nh));
+    EXPECT_EQ(GToNCHW::id(), matching_test::opName(tgm, op2_nh));
+
+    EXPECT_EQ(1u, tmp_nh->outEdges().size());
+    EXPECT_TRUE(matching_test::isConsumedBy(tgm, bgr_nh, op1_nh));
+    EXPECT_TRUE(matching_test::isConsumedBy(tgm, tmp_nh, op2_nh));
+
+    EXPECT_EQ(matching_test::S{ op1_nh }, match.startOps());
+    EXPECT_EQ(matching_test::S{ op2_nh }, match.finishOps());
+    EXPECT_EQ(matching_test::V{ bgr_nh }, match.protoIns());
+    EXPECT_EQ(matching_test::V{ plr_nh }, match.protoOuts());
+}
+
+//FIXME: To switch from filter2d kernel (which shall be matched by params too) to another one
+TEST(PatternMatching, MatchChainInTheMiddle)
+{
+    // Pattern
+    ade::Graph pg;
+    {
+        GMat in;
+        GMat tmp = cv::gapi::filter2D(in, -1, {});
+        GMat out = cv::gapi::filter2D(tmp, -1, {});
+        matching_test::initGModel(pg, cv::GIn(in), cv::GOut(out));
+   }
+
+    // Test
+    ade::Graph tg;
+    GMat in;
+    GMat tmp1 = cv::gapi::erode3x3(in);
+    GMat tmp2 = cv::gapi::filter2D(tmp1, -1, {});
+    GMat tmp3 = cv::gapi::filter2D(tmp2, -1, {});
+    GMat out = cv::gapi::dilate3x3(tmp3);
+    matching_test::initGModel(tg, cv::GIn(in), cv::GOut(out));
+
+    // Pattern Matching
+    cv::gimpl::GModel::Graph pgm(pg);
+    cv::gimpl::GModel::Graph tgm(tg);
+    cv::gimpl::SubgraphMatch match = cv::gimpl::findMatches(pg, tg);
+
+    // Inspecting results:
+    EXPECT_TRUE(match.ok());
+
+    auto nodes = match.nodes();
+    EXPECT_EQ(5u, nodes.size());
+
+    const auto tmp1_nh = cv::gimpl::GModel::dataNodeOf(tgm, tmp1);
+    const auto tmp2_nh = cv::gimpl::GModel::dataNodeOf(tgm, tmp2);
+    const auto tmp3_nh = cv::gimpl::GModel::dataNodeOf(tgm, tmp3);
+    const auto op1_nh = cv::gimpl::GModel::producerOf(tgm, tmp2_nh); // 1st filter2D
+    const auto op2_nh = cv::gimpl::GModel::producerOf(tgm, tmp3_nh); // 2nd filter2D
+
+    EXPECT_EQ(matching_test::S({tmp1_nh, tmp2_nh, tmp3_nh, op1_nh, op2_nh}), nodes);
+
+    EXPECT_EQ(cv::gapi::imgproc::GFilter2D::id(), matching_test::opName(tgm, op1_nh));
+    EXPECT_EQ(cv::gapi::imgproc::GFilter2D::id(), matching_test::opName(tgm, op2_nh));
+
+    EXPECT_EQ(1u, tmp2_nh->outEdges().size());
+    EXPECT_TRUE(matching_test::isConsumedBy(tgm, tmp1_nh, op1_nh));
+    EXPECT_TRUE(matching_test::isConsumedBy(tgm, tmp2_nh, op2_nh));
+
+    EXPECT_EQ(matching_test::S({op1_nh}), match.startOps());
+    EXPECT_EQ(matching_test::S({op2_nh}), match.finishOps());
+    EXPECT_EQ(matching_test::V{ tmp1_nh }, match.protoIns());
+    EXPECT_EQ(matching_test::V{ tmp3_nh }, match.protoOuts());
+}
+
+TEST(PatternMatching, TestMultipleStartOps1)
+{
+    // Pattern
+    ade::Graph pg;
+    {
+        GMat in1, in2;
+        GMat er = cv::gapi::erode3x3(in1);
+        GMat dil = cv::gapi::dilate3x3(in2);
+        GMat out = cv::gapi::add(er, dil);
+        matching_test::initGModel(pg, cv::GIn(in1, in2), cv::GOut(out));
+    }
+
+    // Test
+    ade::Graph tg;
+
+    GMat in1, in2, in3, in4, in5, in6;
+    GMat er1 = cv::gapi::erode3x3(in1);
+    GMat er2 = cv::gapi::erode3x3(in2);
+    GMat er3 = cv::gapi::erode3x3(in3);
+    GMat er4 = cv::gapi::erode3x3(in4);
+    GMat dil1 = cv::gapi::dilate3x3(in5);
+    GMat dil2 = cv::gapi::dilate3x3(in6);
+    GMat out1 = cv::gapi::add(er1, er2);
+    GMat out2 = cv::gapi::add(er3, dil2);
+    matching_test::initGModel(tg, cv::GIn(in1, in2, in3, in4, in5, in6), cv::GOut(out1, out2, er4, dil1));
+
+    // Pattern Matching
+    cv::gimpl::GModel::Graph pgm(pg);
+    cv::gimpl::GModel::Graph tgm(tg);
+    cv::gimpl::SubgraphMatch match = cv::gimpl::findMatches(pg, tg);
+
+    // Inspecting results:
+    EXPECT_TRUE(match.ok());
+
+    auto nodes = match.nodes();
+    EXPECT_EQ(8u, nodes.size());
+
+    const auto in3_nh = cv::gimpl::GModel::dataNodeOf(tgm, in3);
+    const auto in6_nh = cv::gimpl::GModel::dataNodeOf(tgm, in6);
+    const auto er3_nh = cv::gimpl::GModel::dataNodeOf(tgm, er3);
+    const auto dil2_nh = cv::gimpl::GModel::dataNodeOf(tgm, dil2);
+    const auto out2_nh = cv::gimpl::GModel::dataNodeOf(tgm, out2);
+
+    const auto er_op_nh = cv::gimpl::GModel::producerOf(tgm, er3_nh);
+    const auto dil_op_nh = cv::gimpl::GModel::producerOf(tgm, dil2_nh);
+    const auto add_op_nh = cv::gimpl::GModel::producerOf(tgm, out2_nh);
+
+    EXPECT_EQ(matching_test::S({in3_nh, in6_nh, er3_nh, dil2_nh, out2_nh,
+                                er_op_nh, dil_op_nh, add_op_nh}),
+              nodes);
+
+    EXPECT_EQ(cv::gapi::imgproc::GErode::id(), matching_test::opName(tgm, er_op_nh));
+    EXPECT_EQ(cv::gapi::imgproc::GDilate::id(), matching_test::opName(tgm, dil_op_nh));
+    EXPECT_EQ(cv::gapi::core::GAdd::id(), matching_test::opName(tgm, add_op_nh));
+
+    EXPECT_EQ(1u, er3_nh->outEdges().size());
+    EXPECT_EQ(1u, dil2_nh->outEdges().size());
+    EXPECT_TRUE(matching_test::isConsumedBy(tgm, in3_nh, er_op_nh));
+    EXPECT_TRUE(matching_test::isConsumedBy(tgm, in6_nh, dil_op_nh));
+    EXPECT_TRUE(matching_test::isConsumedBy(tgm, er3_nh, add_op_nh));
+    EXPECT_TRUE(matching_test::isConsumedBy(tgm, dil2_nh, add_op_nh));
+
+    EXPECT_EQ(matching_test::S({ er_op_nh, dil_op_nh }), match.startOps());
+    EXPECT_EQ(matching_test::S{ add_op_nh }, match.finishOps());
+    EXPECT_EQ(matching_test::V({ in3_nh, in6_nh }), match.protoIns());
+    EXPECT_EQ(matching_test::V{ out2_nh }, match.protoOuts());
+}
+
+TEST(PatternMatching, TestMultipleStartOps2)
+{
+    // Pattern
+    ade::Graph pg;
+    {
+        GMat in1, in2;
+        GMat er = cv::gapi::erode3x3(in1);
+        GMat dil = cv::gapi::dilate3x3(in2);
+        GMat out = cv::gapi::add(er, dil);
+        matching_test::initGModel(pg, cv::GIn(in1, in2), cv::GOut(out));
+    }
+
+    // Test
+    ade::Graph tg;
+
+    GMat in1, in2;
+    GMat er = cv::gapi::erode3x3(in1);
+    GMat dil1 = cv::gapi::dilate3x3(in2);
+    GMat dil2 = cv::gapi::dilate3x3(dil1);
+    GMat out = cv::gapi::add(er, dil2);
+    matching_test::initGModel(tg, cv::GIn(in1, in2), cv::GOut(out));
+
+    // Pattern Matching
+    cv::gimpl::GModel::Graph pgm(pg);
+    cv::gimpl::GModel::Graph tgm(tg);
+    cv::gimpl::SubgraphMatch match = cv::gimpl::findMatches(pg, tg);
+
+    // Inspecting results:
+    EXPECT_TRUE(match.ok());
+
+    auto nodes = match.nodes();
+    EXPECT_EQ(8u, nodes.size());
+
+    const auto in1_nh = cv::gimpl::GModel::dataNodeOf(tgm, in1);
+    const auto dil1_nh = cv::gimpl::GModel::dataNodeOf(tgm, dil1);
+    const auto er_nh = cv::gimpl::GModel::dataNodeOf(tgm, er);
+    const auto dil2_nh = cv::gimpl::GModel::dataNodeOf(tgm, dil2);
+    const auto out_nh = cv::gimpl::GModel::dataNodeOf(tgm, out);
+
+    const auto er_op_nh = cv::gimpl::GModel::producerOf(tgm, er_nh);
+    const auto dil_op_nh = cv::gimpl::GModel::producerOf(tgm, dil2_nh);
+    const auto add_op_nh = cv::gimpl::GModel::producerOf(tgm, out_nh);
+
+    EXPECT_EQ(matching_test::S({in1_nh, dil1_nh, er_nh, dil2_nh, out_nh,
+                                er_op_nh, dil_op_nh, add_op_nh}),
+              nodes);
+
+    EXPECT_EQ(cv::gapi::imgproc::GErode::id(), matching_test::opName(tgm, er_op_nh));
+    EXPECT_EQ(cv::gapi::imgproc::GDilate::id(), matching_test::opName(tgm, dil_op_nh));
+    EXPECT_EQ(cv::gapi::core::GAdd::id(), matching_test::opName(tgm, add_op_nh));
+
+    EXPECT_EQ(1u, er_nh->outEdges().size());
+    EXPECT_EQ(1u, dil2_nh->outEdges().size());
+    EXPECT_TRUE(matching_test::isConsumedBy(tgm, in1_nh, er_op_nh));
+    EXPECT_TRUE(matching_test::isConsumedBy(tgm, dil1_nh, dil_op_nh));
+    EXPECT_TRUE(matching_test::isConsumedBy(tgm, er_nh, add_op_nh));
+    EXPECT_TRUE(matching_test::isConsumedBy(tgm, dil2_nh, add_op_nh));
+
+    EXPECT_EQ(matching_test::S({ er_op_nh, dil_op_nh }), match.startOps());
+    EXPECT_EQ(matching_test::S{ add_op_nh }, match.finishOps());
+    EXPECT_EQ(matching_test::V({ in1_nh, dil1_nh }), match.protoIns());
+    EXPECT_EQ(matching_test::V{ out_nh }, match.protoOuts());
+}
+
+TEST(PatternMatching, TestInexactMatchOfInOutData)
+{
+    // Pattern
+    ade::Graph pg;
+    {
+        GMat in;
+        GMat out = cv::gapi::dilate3x3(in);
+        matching_test::initGModel(pg, cv::GIn(in), cv::GOut(out));
+    }
+
+    // Test
+    ade::Graph tg;
+    GMat in;
+    GMat out1 = cv::gapi::erode3x3(in);
+    GMat out2 = cv::gapi::boxFilter(in, -1, cv::Size(3, 3));
+    GMat tmp = cv::gapi::dilate3x3(in);
+    GScalar out3 = cv::gapi::sum(tmp);
+    GScalar out4 = cv::gapi::mean(tmp);
+    matching_test::initGModel(tg, cv::GIn(in), cv::GOut(out1, out2, out3, out4));
+
+    // Pattern Matching
+    cv::gimpl::GModel::Graph pgm(pg);
+    cv::gimpl::GModel::Graph tgm(tg);
+    cv::gimpl::SubgraphMatch match = cv::gimpl::findMatches(pg, tg);
+
+    // Inspecting results:
+    EXPECT_TRUE(match.ok());
+
+    auto nodes = match.nodes();
+    EXPECT_EQ(3u, nodes.size());
+
+    const auto in_nh = cv::gimpl::GModel::dataNodeOf(tgm, in);
+    const auto tmp_nh = cv::gimpl::GModel::dataNodeOf(tgm, tmp);
+
+    const auto op_nh = cv::gimpl::GModel::producerOf(tgm, tmp_nh); // dilate3x3
+
+    EXPECT_EQ(matching_test::S({in_nh, tmp_nh, op_nh}),
+              nodes);
+
+    EXPECT_EQ(cv::gapi::imgproc::GDilate::id(), matching_test::opName(tgm, op_nh));
+
+    EXPECT_TRUE(matching_test::isConsumedBy(tgm, in_nh, op_nh));
+
+
+    EXPECT_EQ(matching_test::S{ op_nh }, match.startOps());
+    EXPECT_EQ(matching_test::S{ op_nh }, match.finishOps());
+    EXPECT_EQ(matching_test::V{ in_nh }, match.protoIns());
+    EXPECT_EQ(matching_test::V{ tmp_nh }, match.protoOuts());
+
+    EXPECT_GT(in_nh->outEdges().size(), 1u);
+    EXPECT_GT(tmp_nh->outEdges().size(), 1u);
+}
+
+//FIXME: The start ops matching shall be reworked to more smarter way.
+// Start ops matching shall get rid of non valid matchings sample,
+// where two identical start ops in the pattern refer to the only one in the test.
+TEST(PatternMatching, TestManySameStartOpsAndHinge)
+{
+    // Pattern
+    ade::Graph pg;
+    {
+        GMat in1, in2, in3;
+        GMat er1 = cv::gapi::erode3x3(in1);
+        GMat er2 = cv::gapi::erode3x3(in2);
+        GMat er3 = cv::gapi::erode3x3(in3);
+        GMat mrg = cv::gapi::merge3(er1, er2, er3);
+        matching_test::initGModel(pg, cv::GIn(in1, in2, in3), cv::GOut(mrg));
+    }
+
+    // Test
+    ade::Graph tg;
+    GMat in1, in2, in3;
+    GMat er1 = cv::gapi::erode3x3(in1);
+    GMat er2 = cv::gapi::erode3x3(in2);
+    GMat er3 = cv::gapi::erode3x3(in3);
+    GMat mrg = cv::gapi::merge3(er1, er2, er3);
+    matching_test::initGModel(tg, cv::GIn(in1, in2, in3), cv::GOut(mrg));
+
+    // Pattern Matching
+    cv::gimpl::GModel::Graph pgm(pg);
+    cv::gimpl::GModel::Graph tgm(tg);
+    cv::gimpl::SubgraphMatch match = cv::gimpl::findMatches(pg, tg);
+
+    // Inspecting results:
+    EXPECT_TRUE(match.ok());
+
+    auto nodes = match.nodes();
+    EXPECT_EQ(11u, nodes.size());
+    EXPECT_EQ(matching_test::S(tgm.nodes().begin(), tgm.nodes().end()),
+              nodes);
+}
+
+//FIXME: The start ops matching shall be reworked to more smarter way.
+// Start ops matching shall get rid of non valid matchings sample,
+// where two identical start ops in the pattern refer to the only one in the test.
+TEST(PatternMatching, TestManySameStartOpsAndHinge2)
+{
+    // Pattern
+    ade::Graph pg;
+    {
+        GMat in1, in2, in3;
+        GMat er1 = cv::gapi::erode3x3(in1);
+        GMat er2 = cv::gapi::erode3x3(in2);
+        GMat er3 = cv::gapi::erode3x3(in3);
+        GMat dil1 = cv::gapi::dilate3x3(er1);
+        GMat dil2 = cv::gapi::dilate3x3(er2);
+        GMat dil3 = cv::gapi::dilate3x3(er3);
+        GMat mrg = cv::gapi::merge3(dil1, dil2, dil3);
+        matching_test::initGModel(pg, cv::GIn(in1, in2, in3), cv::GOut(mrg));
+    }
+
+    // Test
+    ade::Graph tg;
+    GMat in1, in2, in3;
+    GMat er1 = cv::gapi::erode3x3(in1);
+    GMat er2 = cv::gapi::erode3x3(in2);
+    GMat er3 = cv::gapi::erode3x3(in3);
+    GMat dil1 = cv::gapi::dilate3x3(er1);
+    GMat dil2 = cv::gapi::dilate3x3(er2);
+    GMat dil3 = cv::gapi::dilate3x3(er3);
+    GMat mrg = cv::gapi::merge3(dil1, dil2, dil3);
+    matching_test::initGModel(tg, cv::GIn(in1, in2, in3), cv::GOut(mrg));
+
+    // Pattern Matching
+    cv::gimpl::GModel::Graph pgm(pg);
+    cv::gimpl::GModel::Graph tgm(tg);
+    cv::gimpl::SubgraphMatch match = cv::gimpl::findMatches(pg, tg);
+
+    // Inspecting results:
+    EXPECT_TRUE(match.ok());
+
+    auto nodes = match.nodes();
+    EXPECT_EQ(17u, nodes.size());
+    EXPECT_EQ(matching_test::S(tgm.nodes().begin(), tgm.nodes().end()),
+              nodes);
+}
+
+//FIXME: The start ops matching shall be reworked to more smarter way.
+// Start ops matching shall get rid of non valid matchings sample,
+// where two identical start ops in the pattern refer to the only one in the test.
+TEST(PatternMatching, TestTwoChainsOnTheHingeIsomorphism)
+{
+    // Pattern
+    ade::Graph pg;
+    {
+        GMat in1, in2;
+        GMat er1 = cv::gapi::erode3x3(in1);
+        GMat er2 = cv::gapi::erode3x3(in2);
+        GMat mdb = cv::gapi::medianBlur(er1, 3);
+        GMat gb = cv::gapi::gaussianBlur(er2, cv::Size(5, 5), 0.12);
+        GMat conc = cv::gapi::concatVert(mdb, gb);
+        matching_test::initGModel(pg, cv::GIn(in1, in2), cv::GOut(conc));
+    }
+
+    // Test
+    ade::Graph tg;
+    GMat in1, in2;
+    GMat er1 = cv::gapi::erode3x3(in1);
+    GMat er2 = cv::gapi::erode3x3(in2);
+    GMat gb = cv::gapi::gaussianBlur(er1, cv::Size(5, 5), 0.12);
+    GMat mdb = cv::gapi::medianBlur(er2, 3);
+    GMat conc = cv::gapi::concatVert(mdb, gb);
+    matching_test::initGModel(tg, cv::GIn(in1, in2), cv::GOut(conc));
+
+    // Pattern Matching
+    cv::gimpl::GModel::Graph pgm(pg);
+    cv::gimpl::GModel::Graph tgm(tg);
+    cv::gimpl::SubgraphMatch match = cv::gimpl::findMatches(pg, tg);
+
+    // Inspecting results:
+    EXPECT_TRUE(match.ok());
+
+    auto nodes = match.nodes();
+    EXPECT_EQ(12u, nodes.size());
+    EXPECT_EQ(matching_test::S(tgm.nodes().begin(), tgm.nodes().end()),
+              nodes);
+
+    const auto in1_nh = cv::gimpl::GModel::dataNodeOf(tgm, in1);
+    const auto in2_nh = cv::gimpl::GModel::dataNodeOf(tgm, in2);
+
+    EXPECT_EQ(matching_test::V({ in2_nh, in1_nh }), match.protoIns());
+}
+
+TEST(PatternMatching, TestPatternHasMoreInDataNodes)
+{
+    // Pattern
+    ade::Graph pg;
+    {
+        GMat in1, in2, in3;
+        GMat out = cv::gapi::merge3(in1, in2, in3);
+        matching_test::initGModel(pg, cv::GIn(in1, in2, in3), cv::GOut(out));
+    }
+
+    // Test
+    ade::Graph tg;
+    GMat in;
+    GMat out = cv::gapi::merge3(in, in, in);
+    matching_test::initGModel(tg, cv::GIn(in), cv::GOut(out));
+
+    // Pattern Matching
+    cv::gimpl::GModel::Graph pgm(pg);
+    cv::gimpl::GModel::Graph tgm(tg);
+    cv::gimpl::SubgraphMatch match = cv::gimpl::findMatches(pg, tg);
+
+    // Inspecting results:
+    EXPECT_TRUE(match.ok());
+
+    auto nodes = match.nodes();
+    EXPECT_EQ(3u, nodes.size());
+    EXPECT_EQ(matching_test::S(tgm.nodes().begin(), tgm.nodes().end()),
+              nodes);
+
+    const auto in_nh = cv::gimpl::GModel::dataNodeOf(tgm, in);
+
+    EXPECT_EQ(matching_test::V({ in_nh, in_nh, in_nh }), match.protoIns());
+}
+
+TEST(PatternMatching, TestPatternHasFewerInDataNodes)
+{
+    // Pattern
+    ade::Graph pg;
+    {
+        GMat in;
+        GMat out = cv::gapi::merge3(in, in, in);
+        matching_test::initGModel(pg, cv::GIn(in), cv::GOut(out));
+    }
+
+    // Test
+    ade::Graph tg;
+    GMat in1, in2, in3;
+    GMat out = cv::gapi::merge3(in1, in2, in3);
+    matching_test::initGModel(tg, cv::GIn(in1, in2, in3), cv::GOut(out));
+
+    // Pattern Matching
+    cv::gimpl::GModel::Graph pgm(pg);
+    cv::gimpl::GModel::Graph tgm(tg);
+    cv::gimpl::SubgraphMatch match = cv::gimpl::findMatches(pg, tg);
+
+    // Inspecting results:
+    EXPECT_FALSE(match.ok());
+}
+
+TEST(PatternMatching, TestTwoMatchingsOneCorrect)
+{
+    // Pattern
+    ade::Graph pg;
+    {
+        GMat in1, in2;
+        GMat n = cv::gapi::bitwise_not(in1);
+        GMat e = cv::gapi::erode3x3(in1);
+        GMat d = cv::gapi::dilate3x3(in2);
+        GMat out = cv::gapi::merge3(n, e, d);
+        matching_test::initGModel(pg, cv::GIn(in1, in2), cv::GOut(out));
+    }
+
+    // Test
+    ade::Graph tg;
+    GMat in1, in2;
+    GMat n = cv::gapi::bitwise_not(in1);
+    GMat e = cv::gapi::erode3x3(in2);
+    GMat d = cv::gapi::dilate3x3(in2);
+    GMat mrg = cv::gapi::merge3(n, e, d);
+    GMat i, sqi;
+    std::tie(i, sqi) = cv::gapi::integral(mrg);
+    GMat n1 = cv::gapi::bitwise_not(i);
+    GMat e1 = cv::gapi::erode3x3(i);
+    GMat d1 = cv::gapi::dilate3x3(sqi);
+    GMat out = cv::gapi::merge3(n1, e1, d1);
+    matching_test::initGModel(tg, cv::GIn(in1, in2), cv::GOut(out));
+
+    // Pattern Matching
+    cv::gimpl::GModel::Graph pgm(pg);
+    cv::gimpl::GModel::Graph tgm(tg);
+    cv::gimpl::SubgraphMatch match = cv::gimpl::findMatches(pg, tg);
+
+    // Inspecting results:
+    EXPECT_TRUE(match.ok());
+
+    auto nodes = match.nodes();
+    EXPECT_EQ(10u, nodes.size());
+
+    const auto i_nh = cv::gimpl::GModel::dataNodeOf(tgm, i);
+    const auto sqi_nh = cv::gimpl::GModel::dataNodeOf(tgm, sqi);
+    const auto n1_nh = cv::gimpl::GModel::dataNodeOf(tgm, n1);
+    const auto e1_nh = cv::gimpl::GModel::dataNodeOf(tgm, e1);
+    const auto d1_nh = cv::gimpl::GModel::dataNodeOf(tgm, d1);
+    const auto out_nh = cv::gimpl::GModel::dataNodeOf(tgm, out);
+
+    const auto n_op_nh = cv::gimpl::GModel::producerOf(tgm, n1_nh);
+    const auto e_op_nh = cv::gimpl::GModel::producerOf(tgm, e1_nh);
+    const auto d_op_nh = cv::gimpl::GModel::producerOf(tgm, d1_nh);
+    const auto m_op_nh = cv::gimpl::GModel::producerOf(tgm, out_nh);
+
+    EXPECT_EQ(matching_test::S({i_nh, sqi_nh, n1_nh, e1_nh, d1_nh, out_nh,
+                                n_op_nh, e_op_nh, d_op_nh, m_op_nh}), nodes);
+
+    EXPECT_EQ(cv::gapi::core::GNot::id(), matching_test::opName(tgm, n_op_nh));
+    EXPECT_EQ(cv::gapi::imgproc::GErode::id(), matching_test::opName(tgm, e_op_nh));
+    EXPECT_EQ(cv::gapi::imgproc::GDilate::id(), matching_test::opName(tgm, d_op_nh));
+    EXPECT_EQ(cv::gapi::core::GMerge3::id(), matching_test::opName(tgm, m_op_nh));
+
+    EXPECT_TRUE(matching_test::isConsumedBy(tgm, i_nh, n_op_nh));
+    EXPECT_TRUE(matching_test::isConsumedBy(tgm, i_nh, e_op_nh));
+    EXPECT_TRUE(matching_test::isConsumedBy(tgm, sqi_nh, d_op_nh));
+    EXPECT_TRUE(matching_test::isConsumedBy(tgm, n1_nh, m_op_nh));
+    EXPECT_TRUE(matching_test::isConsumedBy(tgm, e1_nh, m_op_nh));
+    EXPECT_TRUE(matching_test::isConsumedBy(tgm, d1_nh, m_op_nh));
+    EXPECT_EQ(1u, n1_nh->outEdges().size());
+    EXPECT_EQ(1u, e1_nh->outEdges().size());
+    EXPECT_EQ(1u, d1_nh->outEdges().size());
+
+    EXPECT_EQ(matching_test::S({n_op_nh, e_op_nh, d_op_nh}), match.startOps());
+    EXPECT_EQ(matching_test::S{m_op_nh}, match.finishOps());
+    EXPECT_EQ(matching_test::V({i_nh, sqi_nh}), match.protoIns());
+    EXPECT_EQ(matching_test::V{out_nh}, match.protoOuts());}
+
+TEST(PatternMatching, CheckNoMatch)
+{
+    // Pattern
+    ade::Graph pg;
+    {
+        GMat in;
+        GMat tmp = cv::gapi::filter2D(in, -1, {});
+        GMat out = cv::gapi::filter2D(tmp, -1, {});
+        matching_test::initGModel(pg, cv::GIn(in), cv::GOut(out));
+   }
+
+    // Test
+    ade::Graph tg;
+    {
+        GMat in;
+        GMat tmp1 = cv::gapi::erode3x3(in);
+        GMat out = cv::gapi::dilate3x3(tmp1);
+        matching_test::initGModel(tg, cv::GIn(in), cv::GOut(out));
+    }
+
+    // Pattern Matching
+    cv::gimpl::GModel::Graph pgm(pg);
+    cv::gimpl::GModel::Graph tgm(tg);
+    cv::gimpl::SubgraphMatch match = cv::gimpl::findMatches(pg, tg);
+
+    // Inspecting results:
+    EXPECT_FALSE(match.ok());
+}
+
+TEST(PatternMatching, adeSmokeTest)
+{
+    ade::Graph g;
+    ade::NodeHandle src = g.createNode();
+    ade::NodeHandle dst = g.createNode();
+    g.link(src, dst);
+    g.link(src, dst);
+
+    EXPECT_EQ(2u, dst->inNodes().size());
+}
+
+} // namespace opencv_test