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 期望两个 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

成员类型定义文档

生成器

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... >  )

内联保护

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 )

保护

---

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

• opencv2/gapi/gcomputation.hpp