Namespaces
namespace	compound

namespace	core

namespace	cpu

namespace	fluid

namespace	imgproc

namespace	ocl

namespace	own

Classes
class	GBackend

class	GKernelPackage
	A container class for heterogeneous kernel implementation collections. More...

Typedefs
using	GLookupOrder = std::vector< GBackend >
	Priority list of backends to use during kernel resolution process.

Functions
GMat	absDiff (const GMat &src1, const GMat &src2)
	Calculates the per-element absolute difference between two matrices.

GMat	absDiffC (const GMat &src, const GScalar &c)
	Calculates absolute value of matrix elements.

GMat	add (const GMat &src1, const GMat &src2, int ddepth=-1)
	Calculates the per-element sum of two matrices.

GMat	addC (const GMat &src1, const GScalar &c, int ddepth=-1)
	Calculates the per-element sum of matrix and given scalar.

GMat	addC (const GScalar &c, const GMat &src1, int ddepth=-1)

GMat	addWeighted (const GMat &src1, double alpha, const GMat &src2, double beta, double gamma, int ddepth=-1)
	Calculates the weighted sum of two matrices.

GMat	BGR2Gray (const GMat &src)
	Converts an image from BGR color space to gray-scaled. The conventional ranges for B, G, and R channel values are 0 to 255. Resulting gray color value computed as \[\texttt{dst} (I)= \texttt{0.114} * \texttt{src}(I).B + \texttt{0.587} * \texttt{src}(I).G + \texttt{0.299} * \texttt{src}(I).R \] .

GMat	BGR2LUV (const GMat &src)
	Converts an image from BGR color space to LUV color space.

GMat	BGR2YUV (const GMat &src)
	Converts an image from BGR color space to YUV color space.

GMat	bitwise_and (const GMat &src1, const GMat &src2)
	computes bitwise conjunction of the two matrixes (src1 & src2) Calculates the per-element bit-wise logical conjunction of two matrices of the same size.

GMat	bitwise_and (const GMat &src1, const GScalar &src2)

GMat	bitwise_not (const GMat &src)
	Inverts every bit of an array. The function bitwise_not calculates per-element bit-wise inversion of the input matrix: \[\texttt{dst} (I) = \neg \texttt{src} (I)\] .

GMat	bitwise_or (const GMat &src1, const GMat &src2)
	computes bitwise disjunction of the two matrixes (src1 \| src2) Calculates the per-element bit-wise logical disjunction of two matrices of the same size.

GMat	bitwise_or (const GMat &src1, const GScalar &src2)

GMat	bitwise_xor (const GMat &src1, const GMat &src2)
	computes bitwise logical "exclusive or" of the two matrixes (src1 ^ src2) Calculates the per-element bit-wise logical "exclusive or" of two matrices of the same size.

GMat	bitwise_xor (const GMat &src1, const GScalar &src2)

GMat	blur (const GMat &src, const Size &ksize, const Point &anchor=Point(-1,-1), int borderType=BORDER_DEFAULT, const Scalar &borderValue=Scalar(0))
	Blurs an image using the normalized box filter.

GMat	boxFilter (const GMat &src, int dtype, const Size &ksize, const Point &anchor=Point(-1,-1), bool normalize=true, int borderType=BORDER_DEFAULT, const Scalar &borderValue=Scalar(0))
	Blurs an image using the box filter.

GMat	Canny (const GMat &image, double threshold1, double threshold2, int apertureSize=3, bool L2gradient=false)
	Finds edges in an image using the Canny algorithm.

std::tuple< GMat, GMat >	cartToPolar (const GMat &x, const GMat &y, bool angleInDegrees=false)
	Calculates the magnitude and angle of 2D vectors.

GMat	cmpEQ (const GMat &src1, const GMat &src2)
	Performs the per-element comparison of two matrices checking if elements from first matrix are equal to elements in second.

GMat	cmpEQ (const GMat &src1, const GScalar &src2)

GMat	cmpGE (const GMat &src1, const GMat &src2)
	Performs the per-element comparison of two matrices checking if elements from first matrix are greater or equal compare to elements in second.

GMat	cmpGE (const GMat &src1, const GScalar &src2)

GMat	cmpGT (const GMat &src1, const GMat &src2)
	Performs the per-element comparison of two matrices checking if elements from first matrix are greater compare to elements in second.

GMat	cmpGT (const GMat &src1, const GScalar &src2)

GMat	cmpLE (const GMat &src1, const GMat &src2)
	Performs the per-element comparison of two matrices checking if elements from first matrix are less or equal compare to elements in second.

GMat	cmpLE (const GMat &src1, const GScalar &src2)

GMat	cmpLT (const GMat &src1, const GMat &src2)
	Performs the per-element comparison of two matrices checking if elements from first matrix are less than elements in second.

GMat	cmpLT (const GMat &src1, const GScalar &src2)

GMat	cmpNE (const GMat &src1, const GMat &src2)
	Performs the per-element comparison of two matrices checking if elements from first matrix are not equal to elements in second.

GMat	cmpNE (const GMat &src1, const GScalar &src2)

GKernelPackage	combine (const GKernelPackage &lhs, const GKernelPackage &rhs, const cv::unite_policy policy)

GMat	concatHor (const GMat &src1, const GMat &src2)
	Applies horizontal concatenation to given matrices.

GMat	concatHor (const std::vector< GMat > &v)

GMat	concatVert (const GMat &src1, const GMat &src2)
	Applies vertical concatenation to given matrices.

GMat	concatVert (const std::vector< GMat > &v)

GMat	convertTo (const GMat &src, int rdepth, double alpha=1, double beta=0)
	Converts a matrix to another data depth with optional scaling.

GMat	crop (const GMat &src, const Rect &rect)
	Crops a 2D matrix.

GMat	dilate (const GMat &src, const Mat &kernel, const Point &anchor=Point(-1,-1), int iterations=1, int borderType=BORDER_CONSTANT, const Scalar &borderValue=morphologyDefaultBorderValue())
	Dilates an image by using a specific structuring element.

GMat	dilate3x3 (const GMat &src, int iterations=1, int borderType=BORDER_CONSTANT, const Scalar &borderValue=morphologyDefaultBorderValue())
	Dilates an image by using 3 by 3 rectangular structuring element.

GMat	div (const GMat &src1, const GMat &src2, double scale, int ddepth=-1)
	Performs per-element division of two matrices.

GMat	divC (const GMat &src, const GScalar &divisor, double scale, int ddepth=-1)
	Divides matrix by scalar.

GMat	divRC (const GScalar &divident, const GMat &src, double scale, int ddepth=-1)
	Divides scalar by matrix.

GMat	equalizeHist (const GMat &src)
	Equalizes the histogram of a grayscale image.

GMat	erode (const GMat &src, const Mat &kernel, const Point &anchor=Point(-1,-1), int iterations=1, int borderType=BORDER_CONSTANT, const Scalar &borderValue=morphologyDefaultBorderValue())
	Erodes an image by using a specific structuring element.

GMat	erode3x3 (const GMat &src, int iterations=1, int borderType=BORDER_CONSTANT, const Scalar &borderValue=morphologyDefaultBorderValue())
	Erodes an image by using 3 by 3 rectangular structuring element.

GMat	filter2D (const GMat &src, int ddepth, const Mat &kernel, const Point &anchor=Point(-1,-1), const Scalar &delta=Scalar(0), int borderType=BORDER_DEFAULT, const Scalar &borderValue=Scalar(0))
	Convolves an image with the kernel.

GMat	flip (const GMat &src, int flipCode)
	Flips a 2D matrix around vertical, horizontal, or both axes.

GMat	gaussianBlur (const GMat &src, const Size &ksize, double sigmaX, double sigmaY=0, int borderType=BORDER_DEFAULT, const Scalar &borderValue=Scalar(0))
	Blurs an image using a Gaussian filter.

GMat	inRange (const GMat &src, const GScalar &threshLow, const GScalar &threshUp)
	Applies a range-level threshold to each matrix element.

std::tuple< GMat, GMat >	integral (const GMat &src, int sdepth=-1, int sqdepth=-1)
	Calculates the integral of an image.

void	island (const std::string &name, GProtoInputArgs &&ins, GProtoOutputArgs &&outs)
	Define an tagged island (subgraph) within a computation.

template<typename... KK>
GKernelPackage	kernels ()
	Create a kernel package object containing kernels specified in variadic template argument.

GLookupOrder	lookup_order (std::initializer_list< GBackend > &&list)
	Create a backend lookup order – priority list of backends to use during graph compilation process.

GMat	LUT (const GMat &src, const Mat &lut)
	Performs a look-up table transform of a matrix.

GMat	LUT3D (const GMat &src, const GMat &lut3D, int interpolation=INTER_NEAREST)
	Performs a 3D look-up table transform of a multi-channel matrix.

GMat	LUV2BGR (const GMat &src)
	Converts an image from LUV color space to BGR color space.

GMat	mask (const GMat &src, const GMat &mask)
	Applies a mask to a matrix.

GMat	max (const GMat &src1, const GMat &src2)
	Calculates per-element maximum of two matrices.

GScalar	mean (const GMat &src)
	Calculates an average (mean) of matrix elements.

GMat	medianBlur (const GMat &src, int ksize)
	Blurs an image using the median filter.

GMat	merge3 (const GMat &src1, const GMat &src2, const GMat &src3)

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

GMat	min (const GMat &src1, const GMat &src2)
	Calculates per-element minimum of two matrices.

GMat	mul (const GMat &src1, const GMat &src2, double scale=1.0, int ddepth=-1)
	Calculates the per-element scaled product of two matrices.

GMat	mulC (const GMat &src, double multiplier, int ddepth=-1)
	Multiplies matrix by scalar.

GMat	mulC (const GMat &src, const GScalar &multiplier, int ddepth=-1)

GMat	mulC (const GScalar &multiplier, const GMat &src, int ddepth=-1)

GMat	normalize (const GMat &src, double alpha, double beta, int norm_type, int ddepth=-1)
	Normalizes the norm or value range of an array.

GScalar	normInf (const GMat &src)
	Calculates the absolute infinite norm of a matrix.

GScalar	normL1 (const GMat &src)
	Calculates the absolute L1 norm of a matrix.

GScalar	normL2 (const GMat &src)
	Calculates the absolute L2 norm of a matrix.

GMat	NV12toBGR (const GMat &src_y, const GMat &src_uv)
	Converts an image from NV12 (YUV420p) color space to BGR. The function converts an input image from NV12 color space to RGB. The conventional ranges for Y, U, and V channel values are 0 to 255.

GMat	NV12toRGB (const GMat &src_y, const GMat &src_uv)
	Converts an image from NV12 (YUV420p) color space to RGB. The function converts an input image from NV12 color space to RGB. The conventional ranges for Y, U, and V channel values are 0 to 255.

bool	operator!= (const GBackend &lhs, const GBackend &rhs)

GMat	phase (const GMat &x, const GMat &y, bool angleInDegrees=false)
	Calculates the rotation angle of 2D vectors.

std::tuple< GMat, GMat >	polarToCart (const GMat &magnitude, const GMat &angle, bool angleInDegrees=false)
	Calculates x and y coordinates of 2D vectors from their magnitude and angle.

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

GMat	resize (const GMat &src, const Size &dsize, double fx=0, double fy=0, int interpolation=INTER_LINEAR)
	Resizes an image.

GMat	RGB2Gray (const GMat &src)
	Converts an image from RGB color space to gray-scaled. The conventional ranges for R, G, and B channel values are 0 to 255. Resulting gray color value computed as \[\texttt{dst} (I)= \texttt{0.299} * \texttt{src}(I).R + \texttt{0.587} * \texttt{src}(I).G + \texttt{0.114} * \texttt{src}(I).B \] .

GMat	RGB2Gray (const GMat &src, float rY, float gY, float bY)

GMat	RGB2Lab (const GMat &src)
	Converts an image from RGB color space to Lab color space.

GMat	RGB2YUV (const GMat &src)
	Converts an image from RGB color space to YUV color space.

GMat	select (const GMat &src1, const GMat &src2, const GMat &mask)
	Select values from either first or second of input matrices by given mask. The function set to the output matrix either the value from the first input matrix if corresponding value of mask matrix is 255, or value from the second input matrix (if value of mask matrix set to 0).

GMat	sepFilter (const GMat &src, int ddepth, const Mat &kernelX, const Mat &kernelY, const Point &anchor, const Scalar &delta, int borderType=BORDER_DEFAULT, const Scalar &borderValue=Scalar(0))
	Applies a separable linear filter to a matrix(image).

GMat	Sobel (const GMat &src, int ddepth, int dx, int dy, int ksize=3, double scale=1, double delta=0, int borderType=BORDER_DEFAULT, const Scalar &borderValue=Scalar(0))
	Calculates the first, second, third, or mixed image derivatives using an extended Sobel operator.

std::tuple< GMat, GMat >	SobelXY (const GMat &src, int ddepth, int order, int ksize=3, double scale=1, double delta=0, int borderType=BORDER_DEFAULT, const Scalar &borderValue=Scalar(0))
	Calculates the first, second, third, or mixed image derivatives using an extended Sobel operator.

std::tuple< GMat, GMat, GMat >	split3 (const GMat &src)

std::tuple< GMat, GMat, GMat, GMat >	split4 (const GMat &src)
	Divides a 3-channel (4-channel) matrix into 3(4) single-channel matrices.

GMat	sqrt (const GMat &src)
	Calculates a square root of array elements.

GMat	sub (const GMat &src1, const GMat &src2, int ddepth=-1)
	Calculates the per-element difference between two matrices.

GMat	subC (const GMat &src, const GScalar &c, int ddepth=-1)
	Calculates the per-element difference between matrix and given scalar.

GMat	subRC (const GScalar &c, const GMat &src, int ddepth=-1)
	Calculates the per-element difference between given scalar and the matrix.

GScalar	sum (const GMat &src)
	Calculates sum of all matrix elements.

GMat	threshold (const GMat &src, const GScalar &thresh, const GScalar &maxval, int depth)
	Applies a fixed-level threshold to each matrix element.

std::tuple< GMat, GScalar >	threshold (const GMat &src, const GScalar &maxval, int depth)

GMat	YUV2BGR (const GMat &src)
	Converts an image from YUV color space to BGR color space.

GMat	YUV2RGB (const GMat &src)
	Converts an image from YUV color space to RGB. The function converts an input image from YUV color space to RGB. The conventional ranges for Y, U, and V channel values are 0 to 255.

Function Documentation

GKernelPackage cv::gapi::combine	(	const GKernelPackage &	lhs,
		const GKernelPackage &	rhs,
		const cv::unite_policy	policy
	)

Parameters

lhs	"Left-hand-side" package in the process
rhs	"Right-hand-side" package in the process
policy	Unite policy which is used in case of conflicts – when the same kernel API is implemented in both packages by different backends; cv::unite_policy::KEEP keeps both implementation in the resulting package, while cv::unite_policy::REPLACE gives precedence two kernels from "Right-hand-side".

Returns: a new kernel package.

void cv::gapi::island	(	const std::string &	name,
		GProtoInputArgs &&	ins,
		GProtoOutputArgs &&	outs
	)

Define an tagged island (subgraph) within a computation.

Declare an Island tagged with name and defined from ins to outs (exclusively, as ins/outs are data objects, and regioning is done on operations level). Throws if any operation between ins and outs are already assigned to another island.

Islands allow to partition graph into subgraphs, fine-tuning the way it is scheduled by the underlying executor.

Parameters

name	name of the Island to create
ins	vector of input data objects where the subgraph begins
outs	vector of output data objects where the subgraph ends.

The way how an island is defined is similar to how cv::GComputation is defined on input/output data objects. Same rules apply here as well – if there's no functional dependency between inputs and outputs or there's not enough input data objects were specified to properly calculate all outputs, an exception is thrown.

Use cv::GIn() / cv::GOut() to specify input/output vectors.

bool cv::gapi::operator!=	(	const GBackend &	lhs,
		const GBackend &	rhs
	)

inline

Namespaces

Classes

Typedefs

Functions

Function Documentation