Trait opencv::hub_prelude::GComputationTraitConst
source · pub trait GComputationTraitConst {
fn as_raw_GComputation(&self) -> *const c_void;
}Expand description
\addtogroup gapi_main_classes
G-API classes for constructed and compiled graphs. /
GComputation class represents a captured computation graph. GComputation objects form boundaries for expression code user writes with G-API, allowing to compile and execute it.
G-API computations are defined with input/output data
objects. G-API will track automatically which operations connect
specified outputs to the inputs, forming up a call graph to be
executed. The below example expresses calculation of Sobel operator
for edge detection ():
Full pipeline can be now captured with this object declaration:
Input/output data objects on which a call graph should be reconstructed are passed using special wrappers cv::GIn and cv::GOut. G-API will track automatically which operations form a path from inputs to outputs and build the execution graph appropriately.
Note that cv::GComputation doesn’t take ownership on data objects it is defined. Moreover, multiple GComputation objects may be defined on the same expressions, e.g. a smaller pipeline which expects that image gradients are already pre-calculated may be defined like this:
The resulting graph would expect two inputs and produce one output. In this case, it doesn’t matter if gx/gy data objects are results of cv::gapi::Sobel operators – G-API will stop unrolling expressions and building the underlying graph one reaching this data objects.
The way how GComputation is defined is important as its definition specifies graph protocol – the way how the graph should be used. Protocol is defined by number of inputs, number of outputs, and shapes of inputs and outputs.
In the above example, sobelEdge expects one Mat on input and produces one Mat; while sobelEdgeSub expects two Mats on input and produces one Mat. GComputation’s protocol defines how other computation methods should be used – cv::GComputation::compile() and cv::GComputation::apply(). For example, if a graph is defined on two GMat inputs, two cv::Mat objects have to be passed to apply() for execution. GComputation checks protocol correctness in runtime so passing a different number of objects in apply() or passing cv::Scalar instead of cv::Mat there would compile well as a C++ source but raise an exception in run-time. G-API also comes with a typed wrapper cv::GComputationT<> which introduces this type-checking in compile-time.
cv::GComputation itself is a thin object which just captures what the graph is. The compiled graph (which actually process data) is represented by class GCompiled. Use compile() method to generate a compiled graph with given compile options. cv::GComputation can also be used to process data with implicit graph compilation on-the-fly, see apply() for details.
GComputation is a reference-counted object – once defined, all its copies will refer to the same instance.
See also
GCompiled