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 的方式很重要，因为它定义了图的协议 - 使用该图的方式。协议由输入数量、输出数量以及输入和输出的形状定义。

在上面的例子中，sobelEdge 期望一个输入上的 Mat 并产生一个 Mat；而 sobelEdgeSub 期望两个输入上的 Mats 并产生一个 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

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

构造函数和析构函数文档

GComputation() [1/7]

cv::GComputation::GComputation

(

const Generator &

gen

)

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

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

图可以在构造时直接原地定义，使用 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 对象>
	cv.GComputation(	in_, out	) ->	<GComputation 对象>
	cv.GComputation(	in1, in2, out	) ->	<GComputation 对象>

通用 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 对象>
	cv.GComputation(	in_, out	) ->	<GComputation 对象>
	cv.GComputation(	in1, in2, out	) ->	<GComputation 对象>

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

这是一个重载的成员函数，为了方便起见。它与上面的函数的不同之处仅在于它接受的参数。

参数

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

GComputation() [4/7]

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

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

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

这是一个重载的成员函数，为了方便起见。它与上面的函数的不同之处仅在于它接受的参数。

参数

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

GComputation() [5/7]

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

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

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

这是一个重载的成员函数，为了方便起见。它与上面的函数的不同之处仅在于它接受的参数。

参数

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

GComputation() [6/7]

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

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

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

这是一个重载的成员函数，为了方便起见。它与上面的函数的不同之处仅在于它接受的参数。

参数

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 对象>
	cv.GComputation(	in_, out	) ->	<GComputation 对象>
	cv.GComputation(	in1, in2, out	) ->	<GComputation 对象>

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

这是一个重载的成员函数，为了方便起见。它与上面的函数的不同之处仅在于它接受的参数。

参数

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() 中生成的编译对象 - 如果下次使用相同的输入参数（图像格式、图像分辨率等）调用此方法，则将重用底层编译图，无需重新编译。如果新的元数据与缓存的元数据不匹配，则会重新生成底层编译图。

注意

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

参数

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

inline

这是一个重载的成员函数，为了方便起见。它与上面的函数的不同之处仅在于它接受的参数。

接受一个带有元数据描述符的可变参数包，需要为此生成编译对象，然后是表示此过程的编译参数的 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

inline

这是一个重载的成员函数，为了方便起见。它与上面的函数的不同之处仅在于它接受的参数。

接受一个带有元数据描述符的可变参数包，需要为此生成编译对象。

返回值

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

inline

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

inline

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  )

protected

---

此类的文档从以下文件生成

• opencv2/gapi/gcomputation.hpp