Struct opencv::gapi::GComputation

pub struct GComputation { /* private fields */ }

\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 ():

graph_def

Full pipeline can be now captured with this object declaration:

graph_cap_full

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:

graph_cap_sub

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

Implementations

impl GComputation

pub fn new(in_: GMat, out: GMat) -> Result<GComputation>

Defines an unary (one input – one output) computation

Generic GComputation constructor.

Constructs a new graph with a given protocol, specified as a flow of operations connecting input/output objects. Throws if the passed boundaries are invalid, e.g. if there’s no functional dependency (path) between given outputs and inputs.

Parameters

• ins: Input data vector.
• outs: Output data vector.

Note: Don’t construct GProtoInputArgs/GProtoOutputArgs objects directly, use cv::GIn()/cv::GOut() wrapper functions instead.

See also

@ref gapi_data_objects

Overloaded parameters

• in: input GMat of the defined unary computation
• out: output GMat of the defined unary computation

pub fn new_1(in_: GMat, out: GScalar) -> Result<GComputation>

Defines an unary (one input – one output) computation

Generic GComputation constructor.

Constructs a new graph with a given protocol, specified as a flow of operations connecting input/output objects. Throws if the passed boundaries are invalid, e.g. if there’s no functional dependency (path) between given outputs and inputs.

Parameters

• ins: Input data vector.
• outs: Output data vector.

Note: Don’t construct GProtoInputArgs/GProtoOutputArgs objects directly, use cv::GIn()/cv::GOut() wrapper functions instead.

See also

@ref gapi_data_objects

Overloaded parameters

• in: input GMat of the defined unary computation
• out: output GScalar of the defined unary computation

pub fn new_2(in1: GMat, in2: GMat, out: GMat) -> Result<GComputation>

Defines a binary (two inputs – one output) computation

Generic GComputation constructor.

Constructs a new graph with a given protocol, specified as a flow of operations connecting input/output objects. Throws if the passed boundaries are invalid, e.g. if there’s no functional dependency (path) between given outputs and inputs.

Parameters

• ins: Input data vector.
• outs: Output data vector.

Note: Don’t construct GProtoInputArgs/GProtoOutputArgs objects directly, use cv::GIn()/cv::GOut() wrapper functions instead.

See also

@ref gapi_data_objects

Overloaded parameters

• in1: first input GMat of the defined binary computation
• in2: second input GMat of the defined binary computation
• out: output GMat of the defined binary computation

pub fn new_3(in1: GMat, in2: GMat, out: GScalar) -> Result<GComputation>

Defines a binary (two inputs – one output) computation

Generic GComputation constructor.

Constructs a new graph with a given protocol, specified as a flow of operations connecting input/output objects. Throws if the passed boundaries are invalid, e.g. if there’s no functional dependency (path) between given outputs and inputs.

Parameters

• ins: Input data vector.
• outs: Output data vector.

Note: Don’t construct GProtoInputArgs/GProtoOutputArgs objects directly, use cv::GIn()/cv::GOut() wrapper functions instead.

See also

@ref gapi_data_objects

Overloaded parameters

• in1: first input GMat of the defined binary computation
• in2: second input GMat of the defined binary computation
• out: output GScalar of the defined binary computation

pub fn new_4(ins: &Vector<GMat>, outs: &Vector<GMat>) -> Result<GComputation>

Defines a computation with arbitrary input/output number.

Generic GComputation constructor.

Constructs a new graph with a given protocol, specified as a flow of operations connecting input/output objects. Throws if the passed boundaries are invalid, e.g. if there’s no functional dependency (path) between given outputs and inputs.

Parameters

• ins: Input data vector.
• outs: Output data vector.

Note: Don’t construct GProtoInputArgs/GProtoOutputArgs objects directly, use cv::GIn()/cv::GOut() wrapper functions instead.

See also

@ref gapi_data_objects

Overloaded parameters

• ins: vector of inputs GMats for this computation
• outs: vector of outputs GMats for this computation

Use this overload for cases when number of computation inputs/outputs is not known in compile-time – e.g. when graph is programmatically generated to build an image pyramid with the given number of levels, etc.

Trait Implementations

impl Boxed for GComputation

unsafe fn from_raw(ptr: *mut c_void) -> Self

Wrap the specified raw pointer

fn into_raw(self) -> *mut c_void

Return an the underlying raw pointer while consuming this wrapper.

fn as_raw(&self) -> *const c_void

Return the underlying raw pointer.

fn as_raw_mut(&mut self) -> *mut c_void

Return the underlying mutable raw pointer

impl Drop for GComputation

fn drop(&mut self)

Executes the destructor for this type.

impl GComputationTrait for GComputation

fn as_raw_mut_GComputation(&mut self) -> *mut c_void

fn apply(
    &mut self,
    callback: &ExtractArgsCallback,
    args: GCompileArgs
) -> Result<Vector<GRunArg>>

@private – Exclude this function from OpenCV documentation

fn apply_1(
    &mut self,
    ins: &Vector<Mat>,
    outs: &Vector<Mat>,
    args: GCompileArgs
) -> Result<()>

@private – Exclude this function from OpenCV documentation

fn apply_2(&mut self, in_: Mat, out: &mut Mat, args: GCompileArgs) -> Result<()>

Execute an unary computation (with compilation on the fly)

fn apply_3(&mut self, in_: Mat, out: &mut Scalar, args: GCompileArgs) -> Result<()>

Execute an unary computation (with compilation on the fly)

fn apply_4(
    &mut self,
    in1: Mat,
    in2: Mat,
    out: &mut Mat,
    args: GCompileArgs
) -> Result<()>

Execute a binary computation (with compilation on the fly)

fn apply_5(
    &mut self,
    in1: Mat,
    in2: Mat,
    out: &mut Scalar,
    args: GCompileArgs
) -> Result<()>

Execute an binary computation (with compilation on the fly)

fn apply_6(
    &mut self,
    ins: &Vector<Mat>,
    outs: &mut Vector<Mat>,
    args: GCompileArgs
) -> Result<()>

Execute a computation with arbitrary number of inputs/outputs (with compilation on-the-fly).

fn compile_streaming(&mut self, args: GCompileArgs) -> Result<GStreamingCompiled>

Compile the computation for streaming mode.

fn compile_streaming_1(
    &mut self,
    callback: &ExtractMetaCallback,
    args: GCompileArgs
) -> Result<GStreamingCompiled>

@private – Exclude this function from OpenCV documentation

impl GComputationTraitConst for GComputation

fn as_raw_GComputation(&self) -> *const c_void

impl Send for GComputation