Graph API: Geometric, depth and LUT-like image transformations

Functions
GAPI_EXPORTS GMat	cv::gapi::concatHor (const GMat &src1, const GMat &src2)
	Applies horizontal concatenation to given matrices. More...
GAPI_EXPORTS GMat	cv::gapi::concatHor (const std::vector< GMat > &v)
GAPI_EXPORTS GMat	cv::gapi::concatVert (const GMat &src1, const GMat &src2)
	Applies vertical concatenation to given matrices. More...
GAPI_EXPORTS GMat	cv::gapi::concatVert (const std::vector< GMat > &v)
GAPI_EXPORTS GMat	cv::gapi::convertTo (const GMat &src, int rdepth, double alpha=1, double beta=0)
	Converts a matrix to another data depth with optional scaling. More...
GAPI_EXPORTS GMat	cv::gapi::crop (const GMat &src, const Rect &rect)
	Crops a 2D matrix. More...
GAPI_EXPORTS GMat	cv::gapi::flip (const GMat &src, int flipCode)
	Flips a 2D matrix around vertical, horizontal, or both axes. More...
GAPI_EXPORTS GMat	cv::gapi::LUT (const GMat &src, const Mat &lut)
	Performs a look-up table transform of a matrix. More...
GAPI_EXPORTS GMat	cv::gapi::LUT3D (const GMat &src, const GMat &lut3D, int interpolation=INTER_NEAREST)
	Performs a 3D look-up table transform of a multi-channel matrix. More...
GAPI_EXPORTS GMat	cv::gapi::merge3 (const GMat &src1, const GMat &src2, const GMat &src3)
GAPI_EXPORTS GMat	cv::gapi::merge4 (const GMat &src1, const GMat &src2, const GMat &src3, const GMat &src4)
	Creates one 3-channel (4-channel) matrix out of 3(4) single-channel ones. More...
GAPI_EXPORTS GMat	cv::gapi::remap (const GMat &src, const Mat &map1, const Mat &map2, int interpolation, int borderMode=BORDER_CONSTANT, const Scalar &borderValue=Scalar())
	Applies a generic geometrical transformation to an image. More...
GAPI_EXPORTS GMat	cv::gapi::resize (const GMat &src, const Size &dsize, double fx=0, double fy=0, int interpolation=INTER_LINEAR)
	Resizes an image. More...
GAPI_EXPORTS std::tuple< GMat, GMat, GMat >	cv::gapi::split3 (const GMat &src)
GAPI_EXPORTS std::tuple< GMat, GMat, GMat, GMat >	cv::gapi::split4 (const GMat &src)
	Divides a 3-channel (4-channel) matrix into 3(4) single-channel matrices. More...

Detailed Description

Function Documentation

concatHor() [1/2]

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

Applies horizontal concatenation to given matrices.

The function horizontally concatenates two GMat matrices (with the same number of rows).

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]

Output matrix must the same number of rows and depth as the src1 and src2, and the sum of cols of the src1 and src2. Supported matrix data types are CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1.

Note

Function textual ID is "org.opencv.imgproc.transform.concatHor"

Parameters

src1	first input matrix to be considered for horizontal concatenation.
src2	second input matrix to be considered for horizontal concatenation.

See also

concatVert

concatHor() [2/2]

GAPI_EXPORTS GMat cv::gapi::concatHor

(

const std::vector< GMat > &

v

)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. The function horizontally concatenates given number of GMat matrices (with the same number of columns). Output matrix must the same number of columns and depth as the input matrices, and the sum of rows of input matrices.

Parameters

v	vector of input matrices to be concatenated horizontally.

concatVert() [1/2]

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

Applies vertical concatenation to given matrices.

The function vertically concatenates two GMat matrices (with the same number of cols).

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]

Output matrix must the same number of cols and depth as the src1 and src2, and the sum of rows of the src1 and src2. Supported matrix data types are CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1.

Note

Function textual ID is "org.opencv.imgproc.transform.concatVert"

Parameters

src1	first input matrix to be considered for vertical concatenation.
src2	second input matrix to be considered for vertical concatenation.

See also

concatHor

concatVert() [2/2]

GAPI_EXPORTS GMat cv::gapi::concatVert

(

const std::vector< GMat > &

v

)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. The function vertically concatenates given number of GMat matrices (with the same number of columns). Output matrix must the same number of columns and depth as the input matrices, and the sum of rows of input matrices.

Parameters

v	vector of input matrices to be concatenated vertically.

convertTo()

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

Converts a matrix to another data depth with optional scaling.

The method converts source pixel values to the target data depth. saturate_cast<> is applied at the end to avoid possible overflows:

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

Output matrix must be of the same size as input one.

Note

Function textual ID is "org.opencv.core.transform.convertTo"

Parameters

src	input matrix to be converted from.
rdepth	desired output matrix depth or, rather, the depth since the number of channels are the same as the input has; if rdepth is negative, the output matrix will have the same depth as the input.
alpha	optional scale factor.
beta	optional delta added to the scaled values.

Examples:

samples/cpp/stitching_detailed.cpp.

crop()

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

Crops a 2D matrix.

The function crops the matrix by given cv::Rect.

Output matrix must be of the same depth as input one, size is specified by given rect size.

Note

Function textual ID is "org.opencv.core.transform.crop"

Parameters

src	input matrix.
rect	a rect to crop a matrix to

See also

resize

flip()

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

Flips a 2D matrix around vertical, horizontal, or both axes.

The function flips the matrix in one of three different ways (row and column indices are 0-based):

\[\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.\]

The example scenarios of using the function are the following: Vertical flipping of the image (flipCode == 0) to switch between top-left and bottom-left image origin. This is a typical operation in video processing on Microsoft Windows* OS. Horizontal flipping of the image with the subsequent horizontal shift and absolute difference calculation to check for a vertical-axis symmetry (flipCode > 0). Simultaneous horizontal and vertical flipping of the image with the subsequent shift and absolute difference calculation to check for a central symmetry (flipCode < 0). Reversing the order of point arrays (flipCode > 0 or flipCode == 0). Output image must be of the same depth as input one, size should be correct for given flipCode.

Note

Function textual ID is "org.opencv.core.transform.flip"

Parameters

src	input matrix.
flipCode	a flag to specify how to flip the array; 0 means flipping around the x-axis and positive value (for example, 1) means flipping around y-axis. Negative value (for example, -1) means flipping around both axes.

See also

remap

LUT()

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

Performs a look-up table transform of a matrix.

The function LUT fills the output matrix with values from the look-up table. Indices of the entries are taken from the input matrix. That is, the function processes each element of src as follows:

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

Supported matrix data types are CV_8UC1. Output is a matrix of the same size and number of channels as src, and the same depth as lut.

Note

Function textual ID is "org.opencv.core.transform.LUT"

Parameters

src	input matrix of 8-bit elements.
lut	look-up table of 256 elements; in case of multi-channel input array, the table should either have a single channel (in this case the same table is used for all channels) or the same number of channels as in the input matrix.

LUT3D()

GAPI_EXPORTS GMat cv::gapi::LUT3D	(	const GMat &	src,
		const GMat &	lut3D,
		int	interpolation = INTER_NEAREST
	)

Performs a 3D look-up table transform of a multi-channel matrix.

The function LUT3D fills the output matrix with values from the look-up table. Indices of the entries are taken from the input matrix. Interpolation is applied for mapping 0-255 range values to 0-16 range of 3DLUT table. The function processes each element of src as follows:

dst[i][j][k] = lut3D[~src_r][~src_g][~src_b];

where ~ means approximation. Output is a matrix of of CV_8UC3.

Note

Function textual ID is "org.opencv.core.transform.LUT3D"

Parameters

src	input matrix of CV_8UC3.
lut3D	look-up table 17x17x17 3-channel elements.
interpolation	The depth of interpoolation to be used.

merge3()

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

merge4()

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

Creates one 3-channel (4-channel) matrix out of 3(4) single-channel ones.

The function merges several matrices to make a single multi-channel matrix. That is, each element of the output matrix will be a concatenation of the elements of the input matrices, where elements of i-th input matrix are treated as mv[i].channels()-element vectors. Input matrix must be of CV_8UC3 (CV_8UC4) type.

The function split3/split4 does the reverse operation.

Note

Function textual ID for merge3 is "org.opencv.core.transform.merge3"

Function textual ID for merge4 is "org.opencv.core.transform.merge4"

Parameters

src1	first input matrix to be merged
src2	second input matrix to be merged
src3	third input matrix to be merged
src4	fourth input matrix to be merged

See also

split4, split3

remap()

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

Applies a generic geometrical transformation to an image.

The function remap transforms the source image using the specified map:

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

where values of pixels with non-integer coordinates are computed using one of available interpolation methods. \(map_x\) and \(map_y\) can be encoded as separate floating-point maps in \(map_1\) and \(map_2\) respectively, or interleaved floating-point maps of \((x,y)\) in \(map_1\), or fixed-point maps created by using convertMaps. The reason you might want to convert from floating to fixed-point representations of a map is that they can yield much faster (2x) remapping operations. In the converted case, \(map_1\) contains pairs (cvFloor(x), cvFloor(y)) and \(map_2\) contains indices in a table of interpolation coefficients. Output image must be of the same size and depth as input one.

Note

Function textual ID is "org.opencv.core.transform.remap"

Parameters

src	Source image.
map1	The first map of either (x,y) points or just x values having the type CV_16SC2, CV_32FC1, or CV_32FC2.
map2	The second map of y values having the type CV_16UC1, CV_32FC1, or none (empty map if map1 is (x,y) points), respectively.
interpolation	Interpolation method (see cv::InterpolationFlags). The method INTER_AREA is not supported by this function.
borderMode	Pixel extrapolation method (see cv::BorderTypes). When borderMode=BORDER_TRANSPARENT, it means that the pixels in the destination image that corresponds to the "outliers" in the source image are not modified by the function.
borderValue	Value used in case of a constant border. By default, it is 0.

Note

Due to current implementation limitations the size of an input and output images should be less than 32767x32767.

resize()

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

Resizes an image.

The function resizes the image src down to or up to the specified size.

Output image size will have the size dsize (when dsize is non-zero) or the size computed from src.size(), fx, and fy; the depth of output is the same as of src.

If you want to resize src so that it fits the pre-created dst, you may call the function as follows:

// explicitly specify dsize=dst.size(); fx and fy will be computed from that.
resize(src, dst, dst.size(), 0, 0, interpolation);

If you want to decimate the image by factor of 2 in each direction, you can call the function this way:

// specify fx and fy and let the function compute the destination image size.
resize(src, dst, Size(), 0.5, 0.5, interpolation);

To shrink an image, it will generally look best with cv::INTER_AREA interpolation, whereas to enlarge an image, it will generally look best with cv::INTER_CUBIC (slow) or cv::INTER_LINEAR (faster but still looks OK).

Note

Function textual ID is "org.opencv.core.transform.resize"

Parameters

src	input image.
dsize	output image size; if it equals zero, it is computed as: \[\texttt{dsize = Size(round(fx*src.cols), round(fy*src.rows))}\] Either dsize or both fx and fy must be non-zero.
fx	scale factor along the horizontal axis; when it equals 0, it is computed as \[\texttt{(double)dsize.width/src.cols}\]
fy	scale factor along the vertical axis; when it equals 0, it is computed as \[\texttt{(double)dsize.height/src.rows}\]
interpolation	interpolation method, see cv::InterpolationFlags

See also

warpAffine, warpPerspective, remap

split3()

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

(

const GMat &

src

)

split4()

GAPI_EXPORTS std::tuple<GMat, GMat, GMat,GMat> cv::gapi::split4

(

const GMat &

src

)

Divides a 3-channel (4-channel) matrix into 3(4) single-channel matrices.

The function splits a 3-channel (4-channel) matrix into 3(4) single-channel matrices:

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

All output matrices must be in CV_8UC1.

Note

Function textual for split3 ID is "org.opencv.core.transform.split3"

Function textual for split4 ID is "org.opencv.core.transform.split4"

Parameters

src	input CV_8UC4 (CV_8UC3) matrix.

See also

merge3, merge4