图形 API: 图像及其通道的复合函数

详细说明

gapi_colorconvert

函数
GMat	cv::gapi::concatHor (const GMat &src1, const GMat &src2)
	在给定的矩阵上应用水平串联。
GMat	cv::gapi::concatHor (const std::vector< GMat > &v)
GMat	cv::gapi::concatVert (const GMat &src1, const GMat &src2)
	在给定的矩阵上应用垂直串联。
GMat	cv::gapi::concatVert (const std::vector< GMat > &v)
GMat	cv::gapi::convertTo (const GMat &src, int rdepth, double alpha=1, double beta=0)
	将矩阵转换为另一种数据深度，可选择缩放。
GFrame	cv::gapi::copy (const GFrame &in)
	制作输入帧的副本。请注意，此副本可能不是真实的（未实际复制数据）。使用此函数是为了维护图表的契约，例如，当图表输入需要直接传递到输出端时，如流模式一样。
GMat	cv::gapi::copy (const GMat &in)
	制作输入图像的副本。请注意，此副本可能不是真实的（未实际复制数据）。使用此函数是为了维护图表的契约，例如，当图表输入需要直接传递到输出端时，如流模式一样。
GMat	cv::gapi::crop (const GMat &src, const Rect &rect)
	裁剪二维矩阵。
GMat	cv::gapi::flip (const GMat &src, int flipCode)
	围绕垂直轴、水平轴或同时围绕垂直轴和水平轴翻转二维矩阵。
GMat	cv::gapi::LUT (const GMat &src, const Mat &lut)
	执行矩阵的查找表转换。
GMat	cv::gapi::merge3 (const GMat &src1, const GMat &src2, const GMat &src3)
	将 3 个单通道矩阵创建一个 3 通道矩阵。
GMat	cv::gapi::merge4 (const GMat &src1, const GMat &src2, const GMat &src3, const GMat &src4)
	将 4 个单通道矩阵创建一个 4 通道矩阵。
GMat	cv::gapi::normalize (const GMat &src, double alpha, double beta, int norm_type, int ddepth=-1)
	对数组的幅值或值范围进行归一化。
GMat	cv::gapi::remap (const GMat &src, const Mat &map1, const Mat &map2, int interpolation, int borderMode=BORDER_CONSTANT, const Scalar &borderValue=Scalar())
	对图像应用通用的几何变换。
GMat	cv::gapi::resize (const GMat &src, const Size &dsize, double fx=0, double fy=0, int interpolation=INTER_LINEAR)
	调整图像大小。
GMatP	cv::gapi::resizeP (const GMatP &src, const Size &dsize, int interpolation=cv::INTER_LINEAR)
	调整平面图像大小。
std::tuple< GMat, GMat, GMat >	cv::gapi::split3 (const GMat &src)
	将 3 通道矩阵分成 3 个单通道矩阵。
std::tuple< GMat, GMat, GMat, GMat >	cv::gapi::split4 （const GMat &src)
	将 4 通道矩阵划分为 4 个单通道矩阵。
GMat	cv::gapi::warpAffine （const GMat &src, const Mat &M, const Size &dsize, int flags=cv::INTER_LINEAR, int borderMode=cv::BORDER_CONSTANT, const Scalar &borderValue=Scalar())
	将仿射变换应用于图像。
GMat	cv::gapi::warpPerspective （const GMat &src, const Mat &M, const Size &dsize, int flags=cv::INTER_LINEAR, int borderMode=cv::BORDER_CONSTANT, const Scalar &borderValue=Scalar())
	将透视变换应用于图像。

函数文档

concatHor() [1/2]

GMat cv::gapi::concatHor	(	const GMat &	src1,
		const GMat &	src2
	)

Python
	cv.gapi.concatHor(	src1, src2	) ->	retval
	cv.gapi.concatHor(	v	) ->	retval

#include <opencv2/gapi/core.hpp>

在给定的矩阵上应用水平串联。

此函数水平连接两个 GMat 矩阵（行数相同）。

GMat A = { 1, 4,
           2, 5,
           3, 6 };
GMat B = { 7, 10,
           8, 11,
           9, 12 };
 
GMat C = gapi::concatHor(A, B);
//C
//[1, 4, 7, 10;
// 2, 5, 8, 11;
// 3, 6, 9, 12]

输出矩阵必须与 src1 和 src2 行数、深度相同，且是 src1 和 src2 列数之和。支持的矩阵数据类型为 CV_8UC1、CV_8UC3、CV_16UC1、CV_16SC1、CV_32FC1。

注意

功能文本 ID 为“org.opencv.imgproc.transform.concatHor”

参数

src1	考虑水平连接的首个输入矩阵。
src2	考虑水平连接的第二个输入矩阵。

请参见

concatVert

concatHor() [2/2]

GMat cv::gapi::concatHor

(

const std::vector< GMat > &

v

)

Python
	cv.gapi.concatHor(	src1, src2	) ->	retval
	cv.gapi.concatHor(	v	) ->	retval

#include <opencv2/gapi/core.hpp>

为了方便，这是一个重载成员函数。它只在接受的参数方面与上述函数不同。该函数水平连接给定数量的 GMat 矩阵（列数相同）。输出矩阵必须与输入矩阵列数和深度相同，且行数是输入矩阵行数的总和。

参数

v	要水平连接的输入矩阵向量。

concatVert() [1/2]

GMat cv::gapi::concatVert	(	const GMat &	src1,
		const GMat &	src2
	)

Python
	cv.gapi.concatVert(	src1, src2	) ->	retval
	cv.gapi.concatVert(	v	) ->	retval

#include <opencv2/gapi/core.hpp>

在给定的矩阵上应用垂直串联。

该功能垂直连接两个 GMat 矩阵（列数相同）。

GMat A = { 1, 7,
           2, 8,
           3, 9 };
GMat B = { 4, 10,
           5, 11,
           6, 12 };
 
GMat C = gapi::concatVert(A, B);
//C
//[1, 7;
// 2, 8;
// 3, 9;
// 4, 10;
// 5, 11;
// 6, 12]

输出矩阵必须与 src1 和 src2 列数和深度相同，且是 src1 和 src2 行数的总和。支持的矩阵数据类型为 CV_8UC1、CV_8UC3、CV_16UC1、CV_16SC1、CV_32FC1。

注意

功能文本 ID 为“org.opencv.imgproc.transform.concatVert”

参数

src1	考虑垂直连接的首个输入矩阵。
src2	考虑垂直连接的第二个输入矩阵。

请参见

concatHor

concatVert() [2/2]

GMat cv::gapi::concatVert

(

const std::vector< GMat > &

v

)

Python
	cv.gapi.concatVert(	src1, src2	) ->	retval
	cv.gapi.concatVert(	v	) ->	retval

#include <opencv2/gapi/core.hpp>

这是一个提供的重载成员函数，仅为了方便使用。它与上述函数不同的只是它所接受的参数。该函数纵向连接给定数量的 GMat 矩阵（列数相同）。输出矩阵必须与输入矩阵具有相同的列数和深度，且还要等于输入矩阵的行数之和。

参数

v	要纵向连接的输入矩阵的向量。

convertTo()

GMat cv::gapi::convertTo	(	const GMat &	src,
		int	rdepth,
		double	alpha = 1,
		double	beta = 0
	)

Python
	cv.gapi.convertTo(	src, rdepth[, alpha[, beta]]	) ->	retval

#include <opencv2/gapi/core.hpp>

将矩阵转换为另一种数据深度，可选择缩放。

该方法将源像素值转换为目标数据深度。在最后应用 saturate_cast<>，以避免可能发生的溢出

\[m(x,y) = saturate \_ cast<rType>( \alpha (*this)(x,y) + \beta )\]

输出矩阵的大小必须与输入矩阵相同。

注意

函数文本 ID 为“org.opencv.core.transform.convertTo”

参数

src	要从中进行转换的输入矩阵。
rdepth	期望的输出矩阵深度，更确切地说，是深度，因为通道数与输入相同；如果 rdepth 为负值，输出矩阵将与输入具有相同的深度。
alpha	可选的缩放因子。
beta	添加到缩放值中的可选增量。

copy() [1/2]

GFrame cv::gapi::copy

(

const GFrame &

in

)

Python
	cv.gapi.copy(	in_	) ->	retval

#include <opencv2/gapi/streaming/format.hpp>

制作输入帧的副本。请注意，此副本可能不是真实的（未实际复制数据）。使用此函数是为了维护图表的契约，例如，当图表输入需要直接传递到输出端时，如流模式一样。

注意

函数文本 ID 为“org.opencv.streaming.copy”

参数

in

输入帧

返回

输入的复制

copy() [2/2]

GMat cv::gapi::copy

(

const GMat &

in

)

Python
	cv.gapi.copy(	in_	) ->	retval

#include <opencv2/gapi/streaming/format.hpp>

制作输入图像的副本。请注意，此副本可能不是真实的（未实际复制数据）。使用此函数是为了维护图表的契约，例如，当图表输入需要直接传递到输出端时，如流模式一样。

注意

函数文本 ID 为“org.opencv.streaming.copy”

参数

in

输入图像

返回

输入的复制

crop()

GMat cv::gapi::crop	(	const GMat &	src,
		const Rect &	rect
	)

Python
	cv.gapi.crop(	src, rect	) ->	retval

#include <opencv2/gapi/core.hpp>

裁剪二维矩阵。

该函数使用给定的 cv::Rect 裁剪矩阵。

输出矩阵的深度必须与输入矩阵相同，通过给定的矩形大小指定大小。

注意

函数文本 ID 为“org.opencv.core.transform.crop”

参数

src	输入矩阵。
rect	用于裁剪矩阵的矩形

请参见

resize

flip()

GMat cv::gapi::flip	(	const GMat &	src,
		int	flipCode
	)

Python
	cv.gapi.flip(	src, flipCode	) ->	retval

#include <opencv2/gapi/core.hpp>

围绕垂直轴、水平轴或同时围绕垂直轴和水平轴翻转二维矩阵。

该函数以三种不同方式之一翻转矩阵（行和列索引基于 0）

\[\texttt{dst} _{ij} = \left\{ \begin{array}{l l} \texttt{src} _{\texttt{src.rows}-i-1,j} & if\; \texttt{flipCode} = 0 \\ \texttt{src} _{i, \texttt{src.cols} -j-1} & if\; \texttt{flipCode} > 0 \\ \texttt{src} _{ \texttt{src.rows} -i-1, \texttt{src.cols} -j-1} & if\; \texttt{flipCode} < 0 \\ \end{array} \right.\]

使用该函数的示例场景如下：垂直翻转图像（flipCode == 0），以便在左上和左下图像原点之间切换。这是 Microsoft Windows* 操作系统中视频处理中的典型操作。水平翻转图像，随后进行水平移动和平方差计算，以检查是否存在垂直轴对称性（flipCode > 0）。在后续移动和平方差计算中同时水平和垂直翻转图像，以检查是否存在中心对称性（flipCode < 0）。反转点阵列的顺序（flipCode > 0 或 flipCode == 0）。输出图像的深度必须与输入图像的深度相同，大小应适合给定的 flipCode。

注意

函数文本 ID 为“org.opencv.core.transform.flip”

参数

src	输入矩阵。
flipCode	指定如何翻转阵列的标志；0 表示围绕 x 轴翻转，正值（例如 1）表示围绕 y 轴翻转。负值（例如 -1）表示围绕两个轴翻转。

请参见

remap

LUT()

GMat cv::gapi::LUT	(	const GMat &	src,
		const Mat &	lut
	)

Python
	cv.gapi.LUT(	src, lut	) ->	retval

#include <opencv2/gapi/core.hpp>

执行矩阵的查找表转换。

函数 LUT 用查找表中的值填充输出矩阵。条目索引取自输入矩阵。即，该函数处理 src 的每个元素如下所示

\[\texttt{dst} (I) \leftarrow \texttt{lut(src(I))}\]

支持的矩阵数据类型为 CV_8UC1。输出是大小和通道数与 src 相同、深度与 lut 相同的矩阵。

注意

函数文本 ID 为“org.opencv.core.transform.LUT”

参数

src	8 位元素的输入矩阵。
lut	包含 256 个元素的查找表；如果多通道输入数组，则该表应为单通道（这种情况下所有通道使用相同的表），或者通道数应与输入矩阵的通道数相同。

merge3()

GMat cv::gapi::merge3	(	const GMat &	src1,
		const GMat &	src2,
		const GMat &	src3
	)

Python
	cv.gapi.merge3(	src1, src2, src3	) ->	retval

#include <opencv2/gapi/core.hpp>

将 3 个单通道矩阵创建一个 3 通道矩阵。

该函数将多个矩阵合并为一个多通道矩阵。也就是说，输出矩阵的每个元素都将是输入矩阵的元素串联而成，其中第 i 个输入矩阵的元素被视为 mv[i].channels() 元素向量。输出矩阵必须是 CV_8UC3 类型。

split3 函数执行相反的操作。

注意

• 该函数的文本 ID 为“org.opencv.core.transform.merge3”

参数

src1	第一个输入 CV_8UC1 要合并的矩阵。
src2	第二个输入 CV_8UC1 要合并的矩阵。
src3	第三个输入 CV_8UC1 要合并的矩阵。

请参见

merge4, split4, split3

merge4()

GMat cv::gapi::merge4	(	const GMat &	src1,
		const GMat &	src2,
		const GMat &	src3,
		const GMat &	src4
	)

Python
	cv.gapi.merge4(	src1, src2, src3, src4	) ->	retval

#include <opencv2/gapi/core.hpp>

将 4 个单通道矩阵创建一个 4 通道矩阵。

该函数将多个矩阵合并为一个多通道矩阵。也就是说，输出矩阵的每个元素都将是输入矩阵的元素串联而成，其中第 i 个输入矩阵的元素被视为 mv[i].channels() 元素向量。输出矩阵必须是 CV_8UC4 类型。

split4 函数执行相反的操作。

注意

• 该函数的文本 ID 为“org.opencv.core.transform.merge4”

参数

src1	第一个输入 CV_8UC1 要合并的矩阵。
src2	第二个输入 CV_8UC1 要合并的矩阵。
src3	第三个输入 CV_8UC1 要合并的矩阵。
src4	第四个输入 CV_8UC1 要合并的矩阵。

请参见

merge3, split4, split3

normalize()

GMat cv::gapi::normalize	(	const GMat &	src,
		double	alpha,
		double	beta,
		int	norm_type,
		int	ddepth = -1
	)

Python
	cv.gapi.normalize(	src, alpha, beta, norm_type[, ddepth]	) ->	retval

#include <opencv2/gapi/core.hpp>

对数组的幅值或值范围进行归一化。

该函数对输入数组元素进行归一化和位移，使

\[\| \texttt{dst} \| _{L_p}= \texttt{alpha}\]

(其中 p=Inf、1 或 2)，当 normType=NORM_INF、NORM_L1 或 NORM_L2 时，或

\[\min _I \texttt{dst} (I)= \texttt{alpha} , \, \, \max _I \texttt{dst} (I)= \texttt{beta}\]

当normType=NORM_MINMAX（仅适用于密集阵列）时。

注意

函数文本 ID 为“org.opencv.core.normalize”

参数

src	输入阵列。
alpha	要规范化的规范值或范围规范情况下的较低范围边界。
beta	范围规范情况下的较高范围边界；它不适用于规范规范。
norm_type	规范类型（参见cv::NormTypes）。
ddepth	当为负时，输出阵列的类型与src相同；否则，它与src的通道数相同且depth =ddepth。

请参见

norm，Mat::convertTo

remap()

GMat cv::gapi::remap	(	const GMat &	src,
		const Mat &	map1,
		const Mat &	map2,
		int	插值,
		int	borderMode = BORDER_CONSTANT,
		const Scalar &	borderValue = Scalar()
	)

Python
	cv.gapi.remap(	src, map1, map2, interpolation[, borderMode[, borderValue]]	) ->	retval

#include <opencv2/gapi/core.hpp>

对图像应用通用的几何变换。

此函数使用指定映射转换源图像

\[\texttt{dst} (x,y) = \texttt{src} (map_x(x,y),map_y(x,y))\]

其中使用其中一种可用插值方法计算具有非整数坐标的像素值。\(map_x\)和\(map_y\)分别可以编码为\(map_1\)和\(map_2\)中的独立浮点映射，或\(map_1\)中的\((x,y)\)交错浮点映射，或使用convertMaps创建的定点映射。将浮点表示形式转换为定点映射表示形式的原因在于，它们可以产生更快的（2 倍）重新映射操作。在转换情况下，\(map_1\)包含对 (cvFloor(x), cvFloor(y))，\(map_2\)包含插值系数表中的索引。输出图像必须与输入图像具有相同的尺寸和深度。

注意

• 函数文本 ID 为“org.opencv.core.transform.remap”
• 由于当前实现限制，输入和输出图像的尺寸应小于32767x32767。

参数

src	源图像。
map1	第一个映射，可以是具有类型CV_16SC2、CV_32FC1或CV_32FC2的（x，y）点或x值。
map2	具有类型CV_16UC1、CV_32FC1或none的y值（如果map1是（x，y）点，则映射为空）的第二个映射。
插值	插值方法（参见cv::InterpolationFlags）。此函数不支持INTER_AREA和INTER_LINEAR_EXACT方法。
borderMode	像素外推方法（见 cv::BorderTypes）。当 borderMode=BORDER_TRANSPARENT 时，这意味着在目标图像中对应于源图像中“外围”的像素不会被该函数修改。
borderValue	在常数边框的情况下使用的值。默认情况下，它是 0。

resize()

GMat cv::gapi::resize	(	const GMat &	src,
		const Size &	dsize,
		double	fx = 0,
		double	fy = 0,
		int	interpolation = INTER_LINEAR
	)

Python
	cv.gapi.resize(	src, dsize[, fx[, fy[, interpolation]]]	) ->	retval

#include <opencv2/gapi/imgproc.hpp>

调整图像大小。

该函数将图像 src 缩放至指定的大小或缩小至指定的大小。

输出图像大小将等于 dsize（当 dsize 非零时）或从 src.size()、fx 和 fy 中计算出的大小；输出的深度与 src 相同。

如果你想调整 src 的大小，使其适合预先创建的 dst，你可以按如下方式调用该函数

// 明确指定 dsize=dst.size()；fx 和 fy 将由此计算。
resize(src, dst, dst.size(), 0, 0, interpolation);

如果你想按每个方向将图像缩小 2 倍，你可以按这种方式调用该函数

// 指定 fx 和 fy，并让该函数计算目标图像大小。
resize(src, dst, Size(), 0.5, 0.5, interpolation);

为了缩小图像，通常采用 cv::INTER_AREA 插值效果最佳，而为了放大图像，通常采用 cv::INTER_CUBIC（较慢）或 cv::INTER_LINEAR（较快但效果仍然理想）。

注意

函数文本 ID 为 “org.opencv.imgproc.transform.resize”

参数

src	输入图像。
dsize	输出图像大小；如果它等于零，它计算如下： \[\texttt{dsize = Size(round(fx*src.cols), round(fy*src.rows))}\] dsize 或 fx 和 fy 必须非零。
fx	沿水平轴的缩放因子；当它等于 0 时，计算如下： \[\texttt{(double)dsize.width/src.cols}\]
fy	沿垂直轴的缩放因子；当它等于 0 时，计算如下： \[\texttt{(double)dsize.height/src.rows}\]
插值	插值方法，请参阅 cv::InterpolationFlags

请参见

warpAffine, warpPerspective, remap, resizeP

resizeP()

GMatP cv::gapi::resizeP	(	const GMatP &	src,
		const Size &	dsize,
		int	interpolation = cv::INTER_LINEAR
	)

#include <opencv2/gapi/imgproc.hpp>

调整平面图像大小。

该功能将图像大小调整为指定的尺寸。平面图像内存布局是三个平面连续存在于内存中，因此图像高度应为平面高度*平面数量，图像类型为 CV_8UC1。

输出图像大小将具有大小 dsize，输出的深度与 src 相同。

注意

函数文本 ID 为“org.opencv.imgproc.transform.resizeP”

参数

src	输入图像，必须是 CV_8UC1 类型；
dsize	输出图像大小；
插值	插值方法，目前仅支持 cv::INTER_LINEAR

请参见

warpAffine, warpPerspective, remap, resize

split3()

std::tuple< GMat, GMat, GMat > cv::gapi::split3

(

const GMat &

src

)

Python
	cv.gapi.split3(	src	) ->	retval

#include <opencv2/gapi/core.hpp>

将 3 通道矩阵分成 3 个单通道矩阵。

该功能将 3 通道矩阵拆分为 3 个单通道矩阵

\[\texttt{mv} [c](I) = \texttt{src} (I)_c\]

所有输出矩阵必须是 CV_8UC1 类型。

merge3 函数执行逆运算。

注意

• 函数文本 ID 为“org.opencv.core.transform.split3”

参数

src	输入 CV_8UC3 矩阵。

请参见

split4，merge3，merge4

split4()

std::tuple< GMat，GMat，GMat，GMat > cv::gapi::split4

(

const GMat &

src

)

Python
	cv.gapi.split4(	src	) ->	retval

#include <opencv2/gapi/core.hpp>

将 4 通道矩阵划分为 4 个单通道矩阵。

该函数将一个 4 通道矩阵拆分为 4 个单通道矩阵

\[\texttt{mv} [c](I) = \texttt{src} (I)_c\]

所有输出矩阵必须是 CV_8UC1 类型。

merge4 函数执行相反的操作。

注意

• 函数文本 ID 是“org.opencv.core.transform.split4”

参数

src	输入 CV_8UC4 矩阵。

请参见

split3，merge3，merge4

warpAffine()

GMat cv::gapi::warpAffine	(	const GMat &	src,
		const Mat &	M,
		const Size &	dsize,
		int	flags = cv::INTER_LINEAR，
		int	borderMode = cv::BORDER_CONSTANT，
		const Scalar &	borderValue = Scalar()
	)

Python
	cv.gapi.warpAffine(	src，M，dsize[, flags[, borderMode[, borderValue]]]	) ->	retval

#include <opencv2/gapi/core.hpp>

将仿射变换应用于图像。

该函数使用指定的矩阵对源图像进行变换

\[\texttt{dst} (x,y) = \texttt{src} ( \texttt{M} _{11} x + \texttt{M} _{12} y + \texttt{M} _{13}, \texttt{M} _{21} x + \texttt{M} _{22} y + \texttt{M} _{23})\]

当标志 WARP_INVERSE_MAP 设置时。否则，首先用 invertAffineTransform 对变换取反，然后将其放入上述公式中，而不是 M。该函数不能就地操作。

参数

src	输入图像。
M	\(2\times 3\) 变换矩阵。
dsize	输出图像的大小。
flags	插值方法的组合（请参见 插值标志）和可选标志 WARP_INVERSE_MAP 表示 M 是反向变换（\(\texttt{dst}\rightarrow\texttt{src}\)）。
borderMode	像素外推方法（参见 BorderTypes）；不支持 borderMode=BORDER_TRANSPARENT
borderValue	在恒定边界情况下使用的值；默认值为 0。

请参见

warpPerspective、resize、remap、getRectSubPix、transform

warpPerspective()

GMat cv::gapi::warpPerspective	(	const GMat &	src,
		const Mat &	M,
		const Size &	dsize,
		int	flags = cv::INTER_LINEAR，
		int	borderMode = cv::BORDER_CONSTANT，
		const Scalar &	borderValue = Scalar()
	)

Python
	cv.gapi.warpPerspective(	src，M，dsize[, flags[, borderMode[, borderValue]]]	) ->	retval

#include <opencv2/gapi/core.hpp>

将透视变换应用于图像。

warpPerspective 函数使用指定的矩阵转换源图像

\[\texttt{dst} (x,y) = \texttt{src} \left ( \frac{M_{11} x + M_{12} y + M_{13}}{M_{31} x + M_{32} y + M_{33}} , \frac{M_{21} x + M_{22} y + M_{23}}{M_{31} x + M_{32} y + M_{33}} \right )\]

当设置了标志 WARP_INVERSE_MAP 时。否则，首先反转变换，然后再将它作为 M 的值代入上述公式。该函数不能就地操作。

参数

src	输入图像。
M	\(3\times 3\) 变换矩阵。
dsize	输出图像的大小。
flags	插值方法（INTER_LINEAR 或 INTER_NEAREST）的组合，以及可选标志 WARP_INVERSE_MAP，它将 M 设置为逆变换（\(\texttt{dst}\rightarrow\texttt{src}\)）。
borderMode	像素外推方法（BORDER_CONSTANT 或 BORDER_REPLICATE）。
borderValue	在恒定边界情况下使用的值；默认值为 0。

请参见

warpAffine、resize、remap、getRectSubPix、perspectiveTransform