cv::GComputation 类参考

GComputation 类表示一个捕获的计算图。GComputation 对象为用户使用 G-API 编写的表达式代码构建边界，使其能够被编译和执行。更多...

#include <opencv2/gapi/gcomputation.hpp>

cv::GComputation 的协作图

公开类型
typedef std::function< GComputation()>	Generator

公开成员函数
	GComputation (const Generator &gen)
	使用生成器函数定义计算。
	GComputation (const std::vector< GMat > &ins, const std::vector< GMat > &outs)
	定义具有任意输入/输出数量的计算。
GAPI_WRAP	GComputation (GMat in, GMat out)
	定义一元（一个输入 – 一个输出）计算。
GAPI_WRAP	GComputation (GMat in, GScalar out)
	定义一元（一个输入 – 一个输出）计算。
GAPI_WRAP	GComputation (GMat in1, GMat in2, GMat out)
	定义二元（两个输入 – 一个输出）计算。
	GComputation (GMat in1, GMat in2, GScalar out)
	定义二元（两个输入 – 一个输出）计算。
GAPI_WRAP	GComputation (GProtoInputArgs &&ins, GProtoOutputArgs &&outs)
	通用的 GComputation 构造函数。
void	apply (const std::vector< cv::Mat > &ins, std::vector< cv::Mat > &outs, GCompileArgs &&args={})
	执行具有任意数量输入/输出的计算（带有即时编译）。
void	apply (cv::Mat in, cv::Mat &out, GCompileArgs &&args={})
	执行一元计算（带有即时编译）。
void	apply (cv::Mat in, cv::Scalar &out, GCompileArgs &&args={})
	执行一元计算（带有即时编译）。
void	apply (cv::Mat in1, cv::Mat in2, cv::Mat &out, GCompileArgs &&args={})
	执行二元计算（带有即时编译）。
void	apply (cv::Mat in1, cv::Mat in2, cv::Scalar &out, GCompileArgs &&args={})
	执行二元计算（带有即时编译）。
void	apply (GRunArgs &&ins, GRunArgsP &&outs, GCompileArgs &&args={})
	即时编译图并立即在输入数据向量上执行。
template<typename... Ts>
auto	compile (const Ts &... meta_and_compile_args) -> typename std::enable_if< detail::are_meta_descrs_but_last< Ts... >::value &&std::is_same< GCompileArgs, detail::last_type_t< Ts... > >::value, GCompiled >::type
template<typename... Ts>
auto	compile (const Ts &... metas) -> typename std::enable_if< detail::are_meta_descrs< Ts... >::value, GCompiled >::type
GCompiled	compile (GMetaArgs &&in_metas, GCompileArgs &&args={})
	针对特定的输入格式编译计算。
template<typename... Ts>
auto	compileStreaming (const Ts &... meta_and_compile_args) -> typename std::enable_if< detail::are_meta_descrs_but_last< Ts... >::value &&std::is_same< GCompileArgs, detail::last_type_t< Ts... > >::value, GStreamingCompiled >::type
template<typename... Ts>
auto	compileStreaming (const Ts &... metas) -> typename std::enable_if< detail::are_meta_descrs< Ts... >::value, GStreamingCompiled >::type
GAPI_WRAP GStreamingCompiled	compileStreaming (GCompileArgs &&args={})
	针对流模式编译计算。
GAPI_WRAP GStreamingCompiled	compileStreaming (GMetaArgs &&in_metas, GCompileArgs &&args={})
	针对流模式编译计算。

保护成员函数
template<typename... Ts, int... IIs>
GStreamingCompiled	compileStreaming (const std::tuple< Ts... > &meta_and_compile_args, detail::Seq< IIs... >)
void	recompile (GMetaArgs &&in_metas, GCompileArgs &&args)

详细说明

GComputation 类表示一个捕获的计算图。GComputation 对象为用户使用 G-API 编写的表达式代码构建边界，使其能够被编译和执行。

G-API 计算通过输入/输出数据对象定义。G-API 将自动追踪哪些操作将指定的输出连接到输入，从而形成要执行的调用图。下面的示例表达了用于边缘检测的 Sobel 算子的计算 ( \(G = \sqrt{G_x^2 + G_y^2}\))

    cv::GMat in;
    cv::GMat gx = cv::gapi::Sobel(in, CV_32F, 1, 0);
    cv::GMat gy = cv::gapi::Sobel(in, CV_32F, 0, 1);
    cv::GMat g = cv::gapi::sqrt(cv::gapi::mul(gx, gx) + cv::gapi::mul(gy, gy));
    cv::GMat out = cv::gapi::convertTo(g, CV_8U);

现在可以通过此对象声明捕获完整的流水线

    cv::GComputation sobelEdge(cv::GIn(in), cv::GOut(out));

应在其上重构调用图的输入/输出数据对象使用特殊包装器 cv::GIn 和 cv::GOut 传递。G-API 将自动追踪哪些操作构成了从输入到输出的路径，并相应地构建执行图。

请注意，cv::GComputation 并不拥有其定义的数据对象的所有权。此外，可以在相同的表达式上定义多个 GComputation 对象，例如，可以像这样定义一个预期图像梯度已预先计算的小型流水线

    cv::GComputation sobelEdgeSub(cv::GIn(gx, gy), cv::GOut(out));

生成的图将预期两个输入并产生一个输出。在这种情况下，gx/gy 数据对象是否为 cv::gapi::Sobel 算子的结果并不重要——G-API 在到达这些数据对象时将停止展开表达式并构建底层图。

GComputation 的定义方式非常重要，因为其定义指定了图的 *协议 (protocol)* —— 即图的使用方式。协议由输入的数量、输出的数量以及输入和输出的形状定义。

在上述示例中，sobelEdge 在输入端预期一个 Mat 并产生一个 Mat；而 sobelEdgeSub 在输入端预期两个 Mat 并产生一个 Mat。GComputation 的协议定义了应如何使用其他计算方法 —— cv::GComputation::compile() 和 cv::GComputation::apply()。例如，如果一个图定义在两个 GMat 输入上，则必须将两个 cv::Mat 对象传递给 apply() 以执行。GComputation 在运行时检查协议正确性，因此在 apply() 中传递不同数量的对象或传递 cv::Scalar 而不是 cv::Mat，作为 C++ 源码可能可以编译通过，但在运行时会引发异常。G-API 还提供了一个类型化包装器 cv::GComputationT<>，它在编译时引入了这种类型检查。

cv::GComputation 本身是一个精简对象，仅捕获图的内容。已编译的图（实际处理数据的部分）由 GCompiled 类表示。使用 compile() 方法通过给定的编译选项生成已编译图。cv::GComputation 也可用于通过隐式的即时图编译处理数据，详情请参阅 apply()。

GComputation 是一个引用计数对象 —— 一旦定义，其所有副本都将引用同一个实例。

另请参阅

GCompiled

成员类型定义说明

Generator

std::function<GComputation()> cv::GComputation::Generator

构造函数与析构函数说明

GComputation() [1/7]

cv::GComputation::GComputation

(

const Generator &

gen

)

Python
	cv.GComputation(	ins, outs	) ->	<GComputation object>
	cv.GComputation(	in_, out	) ->	<GComputation object>
	cv.GComputation(	in1, in2, out	) ->	<GComputation object>

使用生成器函数定义计算。

可以在构造时直接使用 lambda 表达式就地定义图

    cv::GComputation sobelEdgeGen([](){
            cv::GMat in;
            cv::GMat gx = cv::gapi::Sobel(in, CV_32F, 1, 0);
            cv::GMat gy = cv::gapi::Sobel(in, CV_32F, 0, 1);
            cv::GMat g = cv::gapi::sqrt(cv::gapi::mul(gx, gx) + cv::gapi::mul(gy, gy));
            cv::GMat out = cv::gapi::convertTo(g, CV_8U);
            return cv::GComputation(in, out);
        });

这可能很有用，因为所有临时对象 (cv::GMats) 和命名空间都可以限制在 lambda 的作用域内，而不会用可能不必要的对象和信息污染父作用域。

参数

gen	返回 cv::GComputation 的生成器函数，参见 Generator。

GComputation() [2/7]

GAPI_WRAP cv::GComputation::GComputation	(	GProtoInputArgs &&	ins,
		GProtoOutputArgs &&	outs )

Python
	cv.GComputation(	ins, outs	) ->	<GComputation object>
	cv.GComputation(	in_, out	) ->	<GComputation object>
	cv.GComputation(	in1, in2, out	) ->	<GComputation object>

通用的 GComputation 构造函数。

使用给定的协议构造一个新图，协议指定为连接输入/输出对象的操作流。如果传递的边界无效，例如给定的输出和输入之间没有函数依赖（路径），则抛出异常。

参数

ins	输入数据向量。
outs	输出数据向量。

注意

不要直接构造 GProtoInputArgs/GProtoOutputArgs 对象，请改用 cv::GIn()/cvGOut() 包装函数。

另请参阅

G-API 数据类型

GComputation() [3/7]

GAPI_WRAP cv::GComputation::GComputation	(	GMat	in,
		GMat	out )

Python
	cv.GComputation(	ins, outs	) ->	<GComputation object>
	cv.GComputation(	in_, out	) ->	<GComputation object>
	cv.GComputation(	in1, in2, out	) ->	<GComputation object>

定义一元（一个输入 – 一个输出）计算。

这是一个重载的成员函数，为方便起见而提供。它与上述函数的区别仅在于所接受的参数不同。

参数

in	定义的一元计算的输入 GMat
out	定义的一元计算的输出 GMat

GComputation() [4/7]

GAPI_WRAP cv::GComputation::GComputation	(	GMat	in,
		GScalar	out )

Python
	cv.GComputation(	ins, outs	) ->	<GComputation object>
	cv.GComputation(	in_, out	) ->	<GComputation object>
	cv.GComputation(	in1, in2, out	) ->	<GComputation object>

定义一元（一个输入 – 一个输出）计算。

这是一个重载的成员函数，为方便起见而提供。它与上述函数的区别仅在于所接受的参数不同。

参数

in	定义的一元计算的输入 GMat
out	定义的一元计算的输出 GScalar

GComputation() [5/7]

GAPI_WRAP cv::GComputation::GComputation	(	GMat	in1,
		GMat	in2,
		GMat	out )

Python
	cv.GComputation(	ins, outs	) ->	<GComputation object>
	cv.GComputation(	in_, out	) ->	<GComputation object>
	cv.GComputation(	in1, in2, out	) ->	<GComputation object>

定义二元（两个输入 – 一个输出）计算。

这是一个重载的成员函数，为方便起见而提供。它与上述函数的区别仅在于所接受的参数不同。

参数

in1	定义的二元计算的第一个输入 GMat
in2	定义的二元计算的第二个输入 GMat
out	定义的二元计算的输出 GMat

GComputation() [6/7]

cv::GComputation::GComputation	(	GMat	in1,
		GMat	in2,
		GScalar	out )

Python
	cv.GComputation(	ins, outs	) ->	<GComputation object>
	cv.GComputation(	in_, out	) ->	<GComputation object>
	cv.GComputation(	in1, in2, out	) ->	<GComputation object>

定义二元（两个输入 – 一个输出）计算。

这是一个重载的成员函数，为方便起见而提供。它与上述函数的区别仅在于所接受的参数不同。

参数

in1	定义的二元计算的第一个输入 GMat
in2	定义的二元计算的第二个输入 GMat
out	定义的二元计算的输出 GScalar

GComputation() [7/7]

cv::GComputation::GComputation	(	const std::vector< GMat > &	ins,
		const std::vector< GMat > &	outs )

Python
	cv.GComputation(	ins, outs	) ->	<GComputation object>
	cv.GComputation(	in_, out	) ->	<GComputation object>
	cv.GComputation(	in1, in2, out	) ->	<GComputation object>

定义具有任意输入/输出数量的计算。

这是一个重载的成员函数，为方便起见而提供。它与上述函数的区别仅在于所接受的参数不同。

参数

ins	此计算的输入 GMats 向量
outs	此计算的输出 GMats 向量

当计算输入/输出的数量在编译时未知时使用此重载 —— 例如，当通过编程方式生成图以构建具有给定层数的图像金字塔时，等等。

成员函数说明

apply() [1/6]

void cv::GComputation::apply	(	const std::vector< cv::Mat > &	ins,
		std::vector< cv::Mat > &	outs,
		GCompileArgs &&	args = {} )

Python
	cv.GComputation.apply(	callback[, args]	) ->	retval

执行具有任意数量输入/输出的计算（带有即时编译）。

这是一个重载的成员函数，为方便起见而提供。它与上述函数的区别仅在于所接受的参数不同。

参数

ins	由计算处理的输入 cv::Mat 对象向量。
outs	由计算产生的输出 cv::Mat 对象向量。
args	底层编译过程的编译参数。

ins/outs 向量中的元素数量必须与定义此 GComputation 时使用的输入/输出数量匹配。

apply() [2/6]

void cv::GComputation::apply	(	cv::Mat	in,
		cv::Mat &	out,
		GCompileArgs &&	args = {} )

Python
	cv.GComputation.apply(	callback[, args]	) ->	retval

执行一元计算（带有即时编译）。

这是一个重载的成员函数，为方便起见而提供。它与上述函数的区别仅在于所接受的参数不同。

参数

in	一元计算的输入 cv::Mat
out	一元计算的输出 cv::Mat
args	底层编译过程的编译参数。

apply() [3/6]

void cv::GComputation::apply	(	cv::Mat	in,
		cv::Scalar &	out,
		GCompileArgs &&	args = {} )

Python
	cv.GComputation.apply(	callback[, args]	) ->	retval

执行一元计算（带有即时编译）。

这是一个重载的成员函数，为方便起见而提供。它与上述函数的区别仅在于所接受的参数不同。

参数

in	一元计算的输入 cv::Mat
out	一元计算的输出 cv::Scalar
args	底层编译过程的编译参数。

apply() [4/6]

void cv::GComputation::apply	(	cv::Mat	in1,
		cv::Mat	in2,
		cv::Mat &	out,
		GCompileArgs &&	args = {} )

Python
	cv.GComputation.apply(	callback[, args]	) ->	retval

执行二元计算（带有即时编译）。

这是一个重载的成员函数，为方便起见而提供。它与上述函数的区别仅在于所接受的参数不同。

参数

in1	二元计算的第一个输入 cv::Mat
in2	二元计算的第二个输入 cv::Mat
out	二元计算的输出 cv::Mat
args	底层编译过程的编译参数。

apply() [5/6]

void cv::GComputation::apply	(	cv::Mat	in1,
		cv::Mat	in2,
		cv::Scalar &	out,
		GCompileArgs &&	args = {} )

Python
	cv.GComputation.apply(	callback[, args]	) ->	retval

执行二元计算（带有即时编译）。

这是一个重载的成员函数，为方便起见而提供。它与上述函数的区别仅在于所接受的参数不同。

参数

in1	二元计算的第一个输入 cv::Mat
in2	二元计算的第二个输入 cv::Mat
out	二元计算的输出 cv::Scalar
args	底层编译过程的编译参数。

apply() [6/6]

void cv::GComputation::apply	(	GRunArgs &&	ins,
		GRunArgsP &&	outs,
		GCompileArgs &&	args = {} )

Python
	cv.GComputation.apply(	callback[, args]	) ->	retval

即时编译图并立即在输入数据向量上执行。

输入/输出数据对象的数量必须匹配 GComputation 的协议，主机数据对象的类型（cv::Mat, cv::Scalar）也必须匹配协议中数据对象的形状（cv::GMat, cv::GScalar）。如果不匹配，将产生运行时异常。

在内部，将为给定的输入格式配置创建一个 cv::GCompiled 对象，然后立即在输入数据上执行该对象。cv::GComputation 会缓存 apply() 中生成的已编译对象 —— 如果下次使用相同的输入参数（图像格式、图像分辨率等）调用此方法，则将重用底层的已编译图而无需重新编译。如果新的元数据与缓存的不匹配，则会重新生成底层的已编译图。

注意

无论是否已通过 apply() 缓存了类似的对象，compile() 总是会触发编译过程并生成一个新的 GCompiled 对象。

参数

ins	要处理的输入数据向量。不要手动创建 GRunArgs 对象，请改用 cv::gin() 包装器。
outs	用于填充结果的输出数据向量。此向量中的 cv::Mat 对象可以为空，G-API 将自动按要求的格式和维度对其进行初始化。不要手动创建 GRunArgsP 对象，请改用 cv::gout() 包装器。
args	要传递给底层编译过程的编译参数列表。不要手动创建 GCompileArgs 对象，请改用 cv::compile_args() 包装器。

另请参阅

G-API 数据类型, G-API 图编译参数

compile() [1/3]

template<typename... Ts>

auto cv::GComputation::compile ( const Ts &... meta_and_compile_args ) -> typename std::enable_if<detail::are_meta_descrs_but_last<Ts...>::value && std::is_same<GCompileArgs, detail::last_type_t<Ts...> >::value, GCompiled>::type

内联

这是一个重载的成员函数，为方便起见而提供。它与上述函数的区别仅在于所接受的参数不同。

接受一个可变参数包，其中包含需要为其生成已编译对象的元数据描述符，后跟表示此过程编译参数的 GCompileArgs 对象。

返回

GCompiled，专门为给定输入参数编译的可执行计算。

compile() [2/3]

template<typename... Ts>

auto cv::GComputation::compile ( const Ts &... metas ) -> typename std::enable_if<detail::are_meta_descrs<Ts...>::value, GCompiled>::type

内联

这是一个重载的成员函数，为方便起见而提供。它与上述函数的区别仅在于所接受的参数不同。

接受一个包含需要为其生成已编译对象的元数据描述符的可变参数包。

返回

GCompiled，专门为给定输入参数编译的可执行计算。

compile() [3/3]

GCompiled cv::GComputation::compile	(	GMetaArgs &&	in_metas,
		GCompileArgs &&	args = {} )

针对特定的输入格式编译计算。

此方法触发编译过程并产生一个新的 GCompiled 对象，该对象随后可以处理给定格式的数据。向已编译计算传递不同格式的数据将产生运行时异常。

参数

in_metas	输入元数据配置向量。使用 cv::descr_of() 从实际数据对象（如 cv::Mat 或 cv::Scalar）获取元数据，或者自行创建。
args	此编译过程的编译参数。编译参数直接影响将生成何种可执行对象，例如，将使用哪些内核（以及哪些设备）来执行计算。

返回

GCompiled，专门为给定输入参数编译的可执行计算。

另请参阅

G-API 图编译参数

compileStreaming() [1/5]

template<typename... Ts, int... IIs>

GStreamingCompiled cv::GComputation::compileStreaming ( const std::tuple< Ts... > & meta_and_compile_args, detail::Seq< IIs... >  )

inlineprotected

Python
	cv.GComputation.compileStreaming(	in_metas[, args]	) ->	retval
	cv.GComputation.compileStreaming(	[, args]	) ->	retval
	cv.GComputation.compileStreaming(	callback[, args]	) ->	retval

compileStreaming() [2/5]

template<typename... Ts>

auto cv::GComputation::compileStreaming ( const Ts &... meta_and_compile_args ) -> typename std::enable_if<detail::are_meta_descrs_but_last<Ts...>::value && std::is_same<GCompileArgs, detail::last_type_t<Ts...> >::value, GStreamingCompiled>::type

内联

Python
	cv.GComputation.compileStreaming(	in_metas[, args]	) ->	retval
	cv.GComputation.compileStreaming(	[, args]	) ->	retval
	cv.GComputation.compileStreaming(	callback[, args]	) ->	retval

这是一个重载的成员函数，为方便起见而提供。它与上述函数的区别仅在于所接受的参数不同。

接受一个可变参数包，其中包含需要为其生成已编译对象的元数据描述符，后跟表示此过程编译参数的 GCompileArgs 对象。

返回

GStreamingCompiled，专门为给定输入参数编译的面向流的可执行计算。

compileStreaming() [3/5]

template<typename... Ts>

auto cv::GComputation::compileStreaming ( const Ts &... metas ) -> typename std::enable_if<detail::are_meta_descrs<Ts...>::value, GStreamingCompiled>::type

内联

Python
	cv.GComputation.compileStreaming(	in_metas[, args]	) ->	retval
	cv.GComputation.compileStreaming(	[, args]	) ->	retval
	cv.GComputation.compileStreaming(	callback[, args]	) ->	retval

这是一个重载的成员函数，为方便起见而提供。它与上述函数的区别仅在于所接受的参数不同。

接受一个包含需要为其生成已编译对象的元数据描述符的可变参数包。

返回

GStreamingCompiled，专门为给定输入参数编译的面向流的可执行计算。

compileStreaming() [4/5]

GAPI_WRAP GStreamingCompiled cv::GComputation::compileStreaming

(

GCompileArgs &&

args = {}

)

Python
	cv.GComputation.compileStreaming(	in_metas[, args]	) ->	retval
	cv.GComputation.compileStreaming(	[, args]	) ->	retval
	cv.GComputation.compileStreaming(	callback[, args]	) ->	retval

针对流模式编译计算。

此方法触发编译过程并产生一个新的 GStreamingCompiled 对象，该对象随后可以处理任何格式的视频流数据。底层机制将自动调整以适应每个新的输入视频流，但请注意，*并非所有* 现有的后端都支持此功能（参见 reshape()）。

参数

args	此编译过程的编译参数。编译参数直接影响将生成何种可执行对象，例如，将使用哪些内核（以及哪些设备）来执行计算。

返回

GStreamingCompiled，针对任何输入图像格式编译的面向流的可执行计算。

另请参阅

G-API 图编译参数

compileStreaming() [5/5]

GAPI_WRAP GStreamingCompiled cv::GComputation::compileStreaming	(	GMetaArgs &&	in_metas,
		GCompileArgs &&	args = {} )

Python
	cv.GComputation.compileStreaming(	in_metas[, args]	) ->	retval
	cv.GComputation.compileStreaming(	[, args]	) ->	retval
	cv.GComputation.compileStreaming(	callback[, args]	) ->	retval

针对流模式编译计算。

此方法触发编译过程并产生一个新的 GStreamingCompiled 对象，该对象随后可以处理给定格式的视频流数据。向已编译计算传递不同格式的流将产生运行时异常。

参数

in_metas	输入元数据配置向量。使用 cv::descr_of() 从实际数据对象（如 cv::Mat 或 cv::Scalar）获取元数据，或者自行创建。
args	此编译过程的编译参数。编译参数直接影响将生成何种可执行对象，例如，将使用哪些内核（以及哪些设备）来执行计算。

返回

GStreamingCompiled，专门为给定输入参数编译的面向流的可执行计算。

另请参阅

G-API 图编译参数

recompile()

void cv::GComputation::recompile ( GMetaArgs && in_metas, GCompileArgs && args )

保护

---

该类的文档由以下文件生成：

• opencv2/gapi/gcomputation.hpp