图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	) ->	返回值
	cv.gapi.concatHor(	v	) ->	返回值

#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	) ->	返回值
	cv.gapi.concatHor(	v	) ->	返回值

#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	) ->	返回值
	cv.gapi.concatVert(	v	) ->	返回值

#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	) ->	返回值
	cv.gapi.concatVert(	v	) ->	返回值

#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]]	) ->	返回值

#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_	) ->	返回值

#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_	) ->	返回值

#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	) ->	返回值

#include <opencv2/gapi/core.hpp>

裁剪二维矩阵。

该函数根据给定的cv::Rect裁剪矩阵。

输出矩阵的深度必须与输入矩阵相同，大小由给定的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	) ->	返回值

#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）表示绕 x 轴和 y 轴都翻转。

参见

重新映射

LUT()

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

Python
	cv.gapi.LUT(	src, lut	) ->	返回值

#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	) ->	返回值

#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	) ->	返回值

#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]	) ->	返回值

#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	要归一化的 norm 值，或者在范围归一化的情况下为较低的范围边界。
beta	在范围归一化的情况下为较高的范围边界；它不用于 norm 归一化。
norm_type	归一化类型（参见 cv::NormTypes）。
ddepth	当为负数时，输出数组与 src 具有相同的类型；否则，它与 src 具有相同的通道数，并且深度 =ddepth。

参见

norm，Mat::convertTo

remap()

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

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

#include <opencv2/gapi/core.hpp>

将通用几何变换应用于图像。

remap 函数使用指定的映射变换源图像：

\[\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 创建的定点映射。您可能想要从浮点表示转换为定点表示映射的原因是它们可以产生快得多的 (2x) 重新映射操作。在转换后的情况下，\(map_1\) 包含对 (cvFloor(x), cvFloor(y))，而 \(map_2\) 包含插值系数表中的索引。输出图像必须与输入图像具有相同的大小和深度。

注意

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

参数

src	源图像。
map1	第一个映射，包含 (x,y) 点或仅包含 x 值，类型为 CV_16SC2、CV_32FC1 或 CV_32FC2。
map2	第二个映射，包含 y 值，类型为 CV_16UC1、CV_32FC1 或无（如果 map1 为 (x,y) 点，则为空映射）。
interpolation	插值方法（参见 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]]]	) ->	返回值

#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}\]
interpolation	插值方法，参见 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>

调整平面图像大小。

该函数将图像 src 调整大小到指定大小或向上缩放。平面图像内存布局是三个连续排列在内存中的平面，因此图像高度应为 plane_height*plane_number，图像类型为 CV_8UC1。

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

注意

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

参数

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

参见

warpAffine，warpPerspective，remap，resize

split3()

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

(

const GMat &

src

)

Python
	cv.gapi.split3(	src	) ->	返回值

#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	) ->	返回值

#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]]]	) ->	返回值

#include <opencv2/gapi/core.hpp>

将仿射变换应用于图像。

warpAffine 函数使用指定的矩阵变换源图像

\[\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	输出图像的大小。
标志	插值方法的组合（参见 InterpolationFlags）以及可选标志 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]]]	) ->	返回值

#include <opencv2/gapi/core.hpp>

将透视变换应用于图像。

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

\[\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 时。否则，先使用 invert 反转变换，然后将其放入上述公式中代替 M。该函数不能就地操作。

参数

src	输入图像。
M	\(3\times 3\) 变换矩阵。
dsize	输出图像的大小。
标志	插值方法的组合（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